feat(issues): add Jira via TWG and tracker properties

apps/server/package.json

@@ -41,6 +41,7 @@
     "@napi-rs/keyring": "^1.3.0",
     "@opencode-ai/sdk": "^1.3.15",
     "@t3tools/issue-tracker-core": "workspace:*",
+    "@t3tools/issue-tracker-jira": "workspace:*",
     "@t3tools/issue-tracker-linear": "workspace:*",
     "@t3tools/provider-acp": "workspace:*",
     "@t3tools/provider-acp-registry": "workspace:*",

apps/server/src/issue/IssueService.test.ts

@@ -520,3 +520,62 @@ describe("IssueService with a standalone tracker", () => {
     }),
   );
 });
+
+it.effect(
+  "resolves a CLI tracker site and preserves internal visibility at the service boundary",
+  () =>
+    Effect.gen(function* () {
+      const jira = IssueTrackerKind.make("jira");
+      const base = fakeStandaloneTracker();
+      let audience: string | undefined;
+      const api: StandaloneIssueTrackerApi = {
+        ...base,
+        kind: jira,
+        standalone: { ...base.standalone, tracker: jira, host: "atlassian.net" },
+        resolveScope: () => ({ host: "demo.atlassian.net", scope: "DEMO" }),
+        capabilities: { ...base.capabilities, internalComments: true },
+        comment: (input) =>
+          Effect.sync(() => {
+            audience = input.visibility;
+          }),
+      };
+      const service = yield* makeService({
+        projects: [project({ id: "web" })],
+        trackers: [api],
+        bindings: { web: { tracker: jira, scope: "demo.atlassian.net/DEMO" } },
+      });
+      const ref = {
+        projectId: "web" as ProjectId,
+        tracker: jira,
+        host: "demo.atlassian.net",
+        scope: "DEMO",
+        key: "DEMO-1",
+      };
+      expect(yield* service.detail(ref)).toMatchObject({
+        host: "demo.atlassian.net",
+        writable: true,
+      });
+      expect(yield* service.resolveUrl("https://demo.atlassian.net/browse/DEMO-1")).toMatchObject({
+        ...ref,
+        writable: true,
+      });
+      yield* service.comment({ ...ref, body: "Team only", visibility: "internal" });
+      expect(audience).toBe("internal");
+      const unsupported = yield* makeService({
+        projects: [project({ id: "web", repository: "acme/web" })],
+        trackers: [fakeTracker()],
+      });
+      expect(
+        yield* Effect.flip(
+          unsupported.comment({
+            projectId: "web" as ProjectId,
+            tracker: GITHUB,
+            scope: "acme/web",
+            key: "1",
+            body: "Internal",
+            visibility: "internal",
+          }),
+        ),
+      ).toMatchObject({ _tag: "IssueOperationError" });
+    }),
+);

apps/server/src/issue/IssueService.ts

@@ -199,11 +199,14 @@ const make = Effect.gen(function* () {
         const binding = bound.get(project.id);
         const api = binding === undefined ? null : registry.get(binding.tracker);
         if (binding === undefined || api === null || !isStandaloneIssueTracker(api)) return null;
+        const target = api.resolveScope
+          ? api.resolveScope(binding.scope)
+          : { host: api.standalone.host, scope: binding.scope };
+        if (target === null) return null;
         return {
-          canonicalKey: `${binding.tracker}:${api.standalone.host}/${binding.scope}`.toLowerCase(),
+          canonicalKey: `${binding.tracker}:${target.host}/${target.scope}`.toLowerCase(),
           tracker: binding.tracker,
-          host: api.standalone.host,
-          scope: binding.scope,
+          ...target,
         };
       }),
       Effect.orElseSucceed(() => null),
@@ -527,6 +530,8 @@ const make = Effect.gen(function* () {
             new IssueOperationError({ operation: "comment", detail: "A comment needs some text." }),
           );
         }
+        if (input.visibility === "internal" && !project.api.capabilities.internalComments)
+          return Effect.fail(unsupported("comment", "internal comments"));
         return project.api.comment === undefined || !project.api.capabilities.comment
           ? Effect.fail(unsupported("comment", "comments"))
           : project.api
@@ -536,6 +541,7 @@ const make = Effect.gen(function* () {
                 scope: project.scope,
                 key: input.key,
                 body: input.body,
+                visibility: input.visibility,
               })
               .pipe(Effect.mapError(toIssueError("comment")));
       }),
@@ -632,7 +638,7 @@ const make = Effect.gen(function* () {
       const preferFirst = (projects: ReadonlyArray<SupportedProject>) =>
         projects.find((project) => project.project.id === preferredProjectId) ?? projects[0];
       const own = preferFirst(
-        onTracker.filter((project) => project.scope.toLowerCase() === parsed.scope),
+        onTracker.filter((project) => project.scope.toLowerCase() === parsed.scope.toLowerCase()),
       );
       const lender = own ?? preferFirst(onTracker);
       if (lender === undefined) {

apps/server/src/issue/IssueTrackerConnections.test.ts

@@ -0,0 +1,63 @@
+import { assert, it } from "@effect/vitest";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import { IssueTrackerKind } from "@t3tools/contracts";
+import { make as makeJira } from "@t3tools/issue-tracker-jira/server/JiraIssueTracker";
+import { SourceControlHost } from "@t3tools/source-control-core/server/SourceControlHost";
+import { ExitCode } from "effect/process/ChildProcessSpawner";
+import { ServerSecretStore } from "../auth/ServerSecretStore.ts";
+import { IssueTrackerBindingsRepository } from "../persistence/IssueTrackerBindings.ts";
+import { IssueTrackerRegistry, fromTrackers } from "./IssueTrackerRegistry.ts";
+import { IssueTrackerConnections, layer } from "./IssueTrackerConnections.ts";
+
+it.effect("uses the environment login without reading or storing a tracker token", () =>
+  Effect.gen(function* () {
+    const jira = yield* makeJira.pipe(
+      Effect.provide(
+        Layer.mock(SourceControlHost)({
+          settings: {} as never,
+          git: {} as never,
+          process: {
+            run: (input) =>
+              Effect.succeed({
+                exitCode: ExitCode(0),
+                stdout: JSON.stringify(
+                  input.args.includes("whoami")
+                    ? { data: { accountId: "a", name: "Demo" } }
+                    : {
+                        request: { site: "demo.atlassian.net" },
+                        data: { projects: [{ id: "1", key: "DEMO", name: "Demo" }] },
+                      },
+                ),
+                stderr: "",
+                stdoutTruncated: false,
+                stderrTruncated: false,
+              }),
+          },
+        }),
+      ),
+    );
+    const connections = yield* IssueTrackerConnections.pipe(
+      Effect.provide(
+        layer.pipe(
+          Layer.provide(
+            Layer.mergeAll(
+              Layer.mock(ServerSecretStore)({}),
+              Layer.mock(IssueTrackerBindingsRepository)({ list: Effect.succeed(new Map()) }),
+              Layer.succeed(IssueTrackerRegistry, fromTrackers([jira])),
+            ),
+          ),
+        ),
+      ),
+    );
+    assert.deepStrictEqual((yield* connections.list).trackers[0]?.scopes, [
+      { key: "demo.atlassian.net/DEMO", name: "Demo" },
+    ]);
+    assert.strictEqual(
+      (yield* Effect.flip(
+        connections.connect({ tracker: IssueTrackerKind.make("jira"), token: "unused" }),
+      )).reason,
+      "rejected",
+    );
+  }),
+);

apps/server/src/issue/IssueTrackerConnections.ts

@@ -98,7 +98,7 @@ const make = Effect.gen(function* () {
       Effect.catch((error) =>
         Effect.succeed<IssueTrackerConnection>({
           ...api.standalone,
-          connected: true,
+          connected: !api.standalone.environmentLogin,
           account: null,
           detail: IssueService.trackerDetail(error),
           scopes: [],
@@ -107,14 +107,16 @@ const make = Effect.gen(function* () {
     );
 
   const current = (api: StandaloneIssueTrackerApi) =>
-    secrets.get(issueTrackerSecretName(api.kind)).pipe(
-      Effect.mapError(secretFailure(api.kind, "The stored credential could not be read.")),
-      Effect.flatMap((stored) =>
-        Option.isNone(stored)
-          ? Effect.succeed(disconnected(api))
-          : status(api, new TextDecoder().decode(stored.value)),
-      ),
-    );
+    api.standalone.environmentLogin
+      ? status(api, "")
+      : secrets.get(issueTrackerSecretName(api.kind)).pipe(
+          Effect.mapError(secretFailure(api.kind, "The stored credential could not be read.")),
+          Effect.flatMap((stored) =>
+            Option.isNone(stored)
+              ? Effect.succeed(disconnected(api))
+              : status(api, new TextDecoder().decode(stored.value)),
+          ),
+        );
 
   const list: IssueTrackerConnections["Service"]["list"] = Effect.all({
     trackers: Effect.forEach(registry.standalone, current, { concurrency: 4 }),
@@ -142,6 +144,12 @@ const make = Effect.gen(function* () {
     "IssueTrackerConnections.connect",
   )(function* (input) {
     const api = yield* requireTracker(input.tracker);
+    if (api.standalone.environmentLogin)
+      return yield* new IssueTrackerConnectionError({
+        tracker: api.kind,
+        reason: "rejected",
+        detail: api.standalone.environmentLogin,
+      });
     if (input.token === null) return yield* disconnect(api);
     const probe = yield* api.probeCredential(input.token).pipe(
       Effect.mapError(

apps/server/src/issue/builtInIssueTrackers.ts

@@ -5,7 +5,10 @@ import * as GitLabIssueTrackerDriver from "@t3tools/source-control-gitlab/server
 import type { IssueTrackerDriver } from "@t3tools/issue-tracker-core/server/driver";
 import * as LinearIssueTrackerDriver from "@t3tools/issue-tracker-linear/server/issueTrackerDriver";
 
+import * as JiraIssueTrackerDriver from "@t3tools/issue-tracker-jira/server/issueTrackerDriver";
+
 const drivers = [
+  JiraIssueTrackerDriver.driver,
   GitHubIssueTrackerDriver.driver,
   GitLabIssueTrackerDriver.driver,
   AzureDevOpsIssueTrackerDriver.driver,

apps/web/src/components/chat/RightPanelSurfaceContent.tsx

@@ -192,6 +192,17 @@ export function RightPanelSurfaceContent(props: {
             key: surface.key,
           }}
           threadRef={threadRef}
+          onSelectIssue={(reference) =>
+            useRightPanelStore.getState().openIssue(threadRef, {
+              projectId: reference.projectId,
+              tracker: reference.tracker,
+              scope: reference.scope,
+              key: reference.key,
+              ...(reference.host ? { host: reference.host } : {}),
+              environmentId:
+                (surface.environmentId as EnvironmentId | undefined) ?? props.environmentId,
+            })
+          }
           onSelectPullRequest={(reference) => {
             useRightPanelStore.getState().openPullRequest(threadRef, {
               projectId: reference.projectId,