@jmoyers/harness 0.1.10 → 0.1.20

package/src/control-plane/stream-server-command.ts

@@ -20,6 +20,7 @@ import type {
 } from '../store/control-plane-store.ts';
 import type { TerminalBufferTail, TerminalSnapshotFrame } from '../terminal/snapshot-oracle.ts';
 import type { PtyExit } from '../pty/pty_host.ts';
+import type { StartSessionRuntimeInput } from './stream-session-runtime-types.ts';
 
 const DEFAULT_TENANT_ID = 'tenant-local';
 const DEFAULT_USER_ID = 'user-local';
@@ -54,21 +55,6 @@ interface SessionControllerState extends StreamSessionController {
   connectionId: string;
 }
 
-interface StartSessionRuntimeInput {
-  readonly sessionId: string;
-  readonly args: readonly string[];
-  readonly initialCols: number;
-  readonly initialRows: number;
-  readonly env?: Record<string, string>;
-  readonly cwd?: string;
-  readonly tenantId?: string;
-  readonly userId?: string;
-  readonly workspaceId?: string;
-  readonly worktreeId?: string;
-  readonly terminalForegroundHex?: string;
-  readonly terminalBackgroundHex?: string;
-}
-
 interface LiveSessionLike {
   attach(
     handlers: {
@@ -206,9 +192,8 @@ interface ExecuteCommandContext {
       workspaceId: string;
       repositoryId?: string;
       projectId?: string;
-      title: string;
-      description?: string;
-      linear?: Record<string, unknown>;
+      title?: string | null;
+      body: string;
     }): ControlPlaneTaskRecord;
     getTask(taskId: string): ControlPlaneTaskRecord | null;
     listTasks(query: {
@@ -224,11 +209,10 @@ interface ExecuteCommandContext {
     updateTask(
       taskId: string,
       input: {
-        title?: string;
-        description?: string;
+        title?: string | null;
+        body?: string;
         repositoryId?: string | null;
         projectId?: string | null;
-        linear?: Record<string, unknown> | null;
       },
     ): ControlPlaneTaskRecord | null;
     deleteTask(taskId: string): void;
@@ -391,10 +375,46 @@ interface ExecuteCommandContext {
       baseBranch: string;
       state: 'open' | 'closed';
       isDraft: boolean;
+      mergedAt: string | null;
       updatedAt: string;
       createdAt: string;
       closedAt: string | null;
     } | null>;
+    findPullRequestForBranch(input: { owner: string; repo: string; headBranch: string }): Promise<{
+      number: number;
+      title: string;
+      url: string;
+      authorLogin: string | null;
+      headBranch: string;
+      headSha: string;
+      baseBranch: string;
+      state: 'open' | 'closed';
+      isDraft: boolean;
+      mergedAt: string | null;
+      updatedAt: string;
+      createdAt: string;
+      closedAt: string | null;
+    } | null>;
+    listPullRequestReviewThreads(input: {
+      owner: string;
+      repo: string;
+      pullNumber: number;
+    }): Promise<
+      readonly {
+        threadId: string;
+        isResolved: boolean;
+        isOutdated: boolean;
+        resolvedByLogin: string | null;
+        comments: readonly {
+          commentId: string;
+          authorLogin: string | null;
+          body: string;
+          url: string | null;
+          createdAt: string;
+          updatedAt: string;
+        }[];
+      }[]
+    >;
     createPullRequest(input: {
       owner: string;
       repo: string;
@@ -413,11 +433,127 @@ interface ExecuteCommandContext {
       baseBranch: string;
       state: 'open' | 'closed';
       isDraft: boolean;
+      mergedAt: string | null;
       updatedAt: string;
       createdAt: string;
       closedAt: string | null;
     }>;
   };
+  getGitHubProjectReviewCache(input: { repositoryId: string; branchName: string }): {
+    repositoryId: string;
+    branchName: string;
+    pr: {
+      number: number;
+      title: string;
+      url: string;
+      authorLogin: string | null;
+      headBranch: string;
+      headSha: string;
+      baseBranch: string;
+      state: 'draft' | 'open' | 'merged' | 'closed';
+      isDraft: boolean;
+      mergedAt: string | null;
+      closedAt: string | null;
+      updatedAt: string;
+      createdAt: string;
+    } | null;
+    openThreads: readonly {
+      threadId: string;
+      isResolved: boolean;
+      isOutdated: boolean;
+      resolvedByLogin: string | null;
+      comments: readonly {
+        commentId: string;
+        authorLogin: string | null;
+        body: string;
+        url: string | null;
+        createdAt: string;
+        updatedAt: string;
+      }[];
+    }[];
+    resolvedThreads: readonly {
+      threadId: string;
+      isResolved: boolean;
+      isOutdated: boolean;
+      resolvedByLogin: string | null;
+      comments: readonly {
+        commentId: string;
+        authorLogin: string | null;
+        body: string;
+        url: string | null;
+        createdAt: string;
+        updatedAt: string;
+      }[];
+    }[];
+    fetchedAtMs: number;
+  } | null;
+  refreshGitHubProjectReviewCache(input: {
+    repositoryId: string;
+    owner: string;
+    repo: string;
+    branchName: string;
+    forceRefresh?: boolean;
+  }): Promise<{
+    repositoryId: string;
+    branchName: string;
+    pr: {
+      number: number;
+      title: string;
+      url: string;
+      authorLogin: string | null;
+      headBranch: string;
+      headSha: string;
+      baseBranch: string;
+      state: 'draft' | 'open' | 'merged' | 'closed';
+      isDraft: boolean;
+      mergedAt: string | null;
+      closedAt: string | null;
+      updatedAt: string;
+      createdAt: string;
+    } | null;
+    openThreads: readonly {
+      threadId: string;
+      isResolved: boolean;
+      isOutdated: boolean;
+      resolvedByLogin: string | null;
+      comments: readonly {
+        commentId: string;
+        authorLogin: string | null;
+        body: string;
+        url: string | null;
+        createdAt: string;
+        updatedAt: string;
+      }[];
+    }[];
+    resolvedThreads: readonly {
+      threadId: string;
+      isResolved: boolean;
+      isOutdated: boolean;
+      resolvedByLogin: string | null;
+      comments: readonly {
+        commentId: string;
+        authorLogin: string | null;
+        body: string;
+        url: string | null;
+        createdAt: string;
+        updatedAt: string;
+      }[];
+    }[];
+    fetchedAtMs: number;
+  }>;
+  readonly linear: {
+    enabled: boolean;
+  };
+  readonly linearApi: {
+    issueByIdentifier(input: { identifier: string }): Promise<{
+      identifier: string;
+      title: string;
+      description: string | null;
+      url: string | null;
+      stateName: string | null;
+      teamKey: string | null;
+    } | null>;
+  };
   readonly streamCursor: number;
   refreshConversationTitle(conversationId: string): Promise<{
     conversation: ControlPlaneConversationRecord;
@@ -564,6 +700,40 @@ function parseGitHubOwnerRepo(remoteUrl: string): { owner: string; repo: string
   return null;
 }
 
+function parseLinearIssueIdentifierFromUrl(issueUrl: string): {
+  identifier: string;
+} | null {
+  const trimmed = issueUrl.trim();
+  if (trimmed.length === 0) {
+    return null;
+  }
+  let parsedUrl: URL;
+  try {
+    parsedUrl = new URL(trimmed);
+  } catch {
+    return null;
+  }
+  if (parsedUrl.protocol !== 'https:') {
+    return null;
+  }
+  const hostname = parsedUrl.hostname.toLowerCase();
+  if (!(hostname === 'linear.app' || hostname.endsWith('.linear.app'))) {
+    return null;
+  }
+  const segments = parsedUrl.pathname.split('/').filter((segment) => segment.length > 0);
+  const issueSegmentIndex = segments.findIndex((segment) => segment.toLowerCase() === 'issue');
+  if (issueSegmentIndex < 0 || issueSegmentIndex + 1 >= segments.length) {
+    return null;
+  }
+  const identifier = segments[issueSegmentIndex + 1]?.trim().toUpperCase() ?? '';
+  if (!/^[A-Z][A-Z0-9]*-\d+$/u.test(identifier)) {
+    return null;
+  }
+  return {
+    identifier,
+  };
+}
+
 function resolveTrackedBranch(input: {
   strategy: 'pinned-then-current' | 'current-only' | 'pinned-only';
   pinnedBranch: string | null;
@@ -647,10 +817,29 @@ function ciRollupFromJobs(
   return 'neutral';
 }
 
+function githubLifecycleStateFromPullRequest(input: {
+  state: 'open' | 'closed';
+  isDraft: boolean;
+  mergedAt: string | null;
+}): 'draft' | 'open' | 'merged' | 'closed' {
+  if (input.state === 'open' && input.isDraft) {
+    return 'draft';
+  }
+  if (input.state === 'open') {
+    return 'open';
+  }
+  if (input.mergedAt !== null) {
+    return 'merged';
+  }
+  return 'closed';
+}
+
 export const streamServerCommandTestInternals = {
   parseGitHubOwnerRepo,
+  parseLinearIssueIdentifierFromUrl,
   resolveTrackedBranch,
   ciRollupFromJobs,
+  githubLifecycleStateFromPullRequest,
 };
 
 export async function executeStreamServerCommand(
@@ -1161,6 +1350,99 @@ export async function executeStreamServerCommand(
     };
   }
 
+  if (command.type === 'github.project-review') {
+    const resolved = resolveProjectGitHubContext(command.directoryId);
+    const storedPr =
+      resolved.repository === null || resolved.trackedBranch === null
+        ? null
+        : (ctx.stateStore.listGitHubPullRequests({
+            repositoryId: resolved.repository.repositoryId,
+            headBranch: resolved.trackedBranch,
+            limit: 1,
+          })[0] ?? null);
+    const storedPrView =
+      storedPr === null
+        ? null
+        : {
+            prRecordId: storedPr.prRecordId,
+            number: storedPr.number,
+            title: storedPr.title,
+            url: storedPr.url,
+            authorLogin: storedPr.authorLogin,
+            headBranch: storedPr.headBranch,
+            headSha: storedPr.headSha,
+            baseBranch: storedPr.baseBranch,
+            state: githubLifecycleStateFromPullRequest({
+              state: storedPr.state,
+              isDraft: storedPr.isDraft,
+              mergedAt: null,
+            }),
+            isDraft: storedPr.isDraft,
+            mergedAt: null,
+            closedAt: storedPr.closedAt,
+            ciRollup: storedPr.ciRollup,
+            updatedAt: storedPr.updatedAt,
+            createdAt: storedPr.createdAt,
+            observedAt: storedPr.observedAt,
+          };
+    if (
+      resolved.repository === null ||
+      resolved.trackedBranch === null ||
+      resolved.ownerRepo === null ||
+      !ctx.github.enabled
+    ) {
+      return {
+        directoryId: resolved.directory.directoryId,
+        repositoryId: resolved.repository?.repositoryId ?? null,
+        branchName: resolved.trackedBranch,
+        branchSource: resolved.trackedBranchSource,
+        pr: storedPrView,
+        openThreads: [],
+        resolvedThreads: [],
+      };
+    }
+    const reviewCache =
+      command.forceRefresh === true
+        ? await ctx.refreshGitHubProjectReviewCache({
+            repositoryId: resolved.repository.repositoryId,
+            owner: resolved.ownerRepo.owner,
+            repo: resolved.ownerRepo.repo,
+            branchName: resolved.trackedBranch,
+            forceRefresh: true,
+          })
+        : ctx.getGitHubProjectReviewCache({
+            repositoryId: resolved.repository.repositoryId,
+            branchName: resolved.trackedBranch,
+          });
+    if (reviewCache === null) {
+      return {
+        directoryId: resolved.directory.directoryId,
+        repositoryId: resolved.repository.repositoryId,
+        branchName: resolved.trackedBranch,
+        branchSource: resolved.trackedBranchSource,
+        pr: storedPrView,
+        openThreads: [],
+        resolvedThreads: [],
+      };
+    }
+    const reviewPr =
+      reviewCache.pr === null
+        ? storedPrView
+        : {
+            ...reviewCache.pr,
+            ciRollup: storedPrView?.ciRollup ?? null,
+          };
+    return {
+      directoryId: resolved.directory.directoryId,
+      repositoryId: resolved.repository.repositoryId,
+      branchName: resolved.trackedBranch,
+      branchSource: resolved.trackedBranchSource,
+      pr: reviewPr,
+      openThreads: reviewCache.openThreads,
+      resolvedThreads: reviewCache.resolvedThreads,
+    };
+  }
+
   if (command.type === 'github.pr-list') {
     const prs = ctx.stateStore.listGitHubPullRequests({
       ...(command.tenantId === undefined ? {} : { tenantId: command.tenantId }),
@@ -1301,6 +1583,66 @@ export async function executeStreamServerCommand(
     };
   }
 
+  if (command.type === 'linear.issue.import') {
+    if (!ctx.linear.enabled) {
+      throw new Error('linear integration is disabled');
+    }
+    const parsedLinearIssue = parseLinearIssueIdentifierFromUrl(command.url);
+    if (parsedLinearIssue === null) {
+      throw new Error('linear issue url required');
+    }
+    const issue = await ctx.linearApi.issueByIdentifier({
+      identifier: parsedLinearIssue.identifier,
+    });
+    if (issue === null) {
+      throw new Error(`linear issue not found: ${parsedLinearIssue.identifier}`);
+    }
+    if (command.repositoryId === undefined && command.projectId === undefined) {
+      throw new Error('linear issue import requires repositoryId or projectId');
+    }
+    const task = ctx.stateStore.createTask({
+      taskId: `task-${randomUUID()}`,
+      tenantId: command.tenantId ?? DEFAULT_TENANT_ID,
+      userId: command.userId ?? DEFAULT_USER_ID,
+      workspaceId: command.workspaceId ?? DEFAULT_WORKSPACE_ID,
+      ...(command.repositoryId === undefined ? {} : { repositoryId: command.repositoryId }),
+      ...(command.projectId === undefined ? {} : { projectId: command.projectId }),
+      title: `${issue.identifier}: ${issue.title}`.trim(),
+      body: [
+        issue.url ?? command.url.trim(),
+        issue.stateName === null ? null : `state: ${issue.stateName}`,
+        issue.teamKey === null ? null : `team: ${issue.teamKey}`,
+        issue.description,
+      ]
+        .filter((entry): entry is string => typeof entry === 'string' && entry.trim().length > 0)
+        .join('\n'),
+    });
+    ctx.publishObservedEvent(
+      {
+        tenantId: task.tenantId,
+        userId: task.userId,
+        workspaceId: task.workspaceId,
+        directoryId: null,
+        conversationId: null,
+      },
+      {
+        type: 'task-created',
+        task: ctx.taskRecord(task),
+      },
+    );
+    return {
+      imported: true,
+      issue: {
+        identifier: issue.identifier,
+        title: issue.title,
+        url: issue.url ?? command.url.trim(),
+        stateName: issue.stateName,
+        teamKey: issue.teamKey,
+      },
+      task: ctx.taskRecord(task),
+    };
+  }
+
   if (command.type === 'conversation.create') {
     const conversation = ctx.stateStore.createConversation({
       conversationId: command.conversationId ?? `conversation-${randomUUID()}`,
@@ -1597,42 +1939,24 @@ export async function executeStreamServerCommand(
       workspaceId: string;
       repositoryId?: string;
       projectId?: string;
-      title: string;
-      description?: string;
-      linear?: {
-        issueId?: string | null;
-        identifier?: string | null;
-        url?: string | null;
-        teamId?: string | null;
-        projectId?: string | null;
-        projectMilestoneId?: string | null;
-        cycleId?: string | null;
-        stateId?: string | null;
-        assigneeId?: string | null;
-        priority?: number | null;
-        estimate?: number | null;
-        dueDate?: string | null;
-        labelIds?: readonly string[] | null;
-      };
+      title?: string | null;
+      body: string;
     } = {
       taskId: command.taskId ?? `task-${randomUUID()}`,
       tenantId: command.tenantId ?? DEFAULT_TENANT_ID,
       userId: command.userId ?? DEFAULT_USER_ID,
       workspaceId: command.workspaceId ?? DEFAULT_WORKSPACE_ID,
-      title: command.title,
+      body: command.body,
     };
+    if (command.title !== undefined) {
+      input.title = command.title;
+    }
     if (command.repositoryId !== undefined) {
       input.repositoryId = command.repositoryId;
     }
     if (command.projectId !== undefined) {
       input.projectId = command.projectId;
     }
-    if (command.description !== undefined) {
-      input.description = command.description;
-    }
-    if (command.linear !== undefined) {
-      input.linear = command.linear;
-    }
     const task = ctx.stateStore.createTask(input);
     ctx.publishObservedEvent(
       {
@@ -1705,31 +2029,16 @@ export async function executeStreamServerCommand(
 
   if (command.type === 'task.update') {
     const update: {
-      title?: string;
-      description?: string;
+      title?: string | null;
+      body?: string;
       repositoryId?: string | null;
       projectId?: string | null;
-      linear?: {
-        issueId?: string | null;
-        identifier?: string | null;
-        url?: string | null;
-        teamId?: string | null;
-        projectId?: string | null;
-        projectMilestoneId?: string | null;
-        cycleId?: string | null;
-        stateId?: string | null;
-        assigneeId?: string | null;
-        priority?: number | null;
-        estimate?: number | null;
-        dueDate?: string | null;
-        labelIds?: readonly string[] | null;
-      } | null;
     } = {};
     if (command.title !== undefined) {
       update.title = command.title;
     }
-    if (command.description !== undefined) {
-      update.description = command.description;
+    if (command.body !== undefined) {
+      update.body = command.body;
     }
     if (command.repositoryId !== undefined) {
       update.repositoryId = command.repositoryId;
@@ -1737,9 +2046,6 @@ export async function executeStreamServerCommand(
     if (command.projectId !== undefined) {
       update.projectId = command.projectId;
     }
-    if (command.linear !== undefined) {
-      update.linear = command.linear;
-    }
     const updated = ctx.stateStore.updateTask(command.taskId, update);
     if (updated === null) {
       throw new Error(`task not found: ${command.taskId}`);
@@ -2494,13 +2800,14 @@ export async function executeStreamServerCommand(
     const attachmentId = state.session.attach(
       {
         onData: (event) => {
+          const chunkBase64 = event.chunk.toString('base64');
           ctx.sendToConnection(
             connection.id,
             {
               kind: 'pty.output',
               sessionId: command.sessionId,
               cursor: event.cursor,
-              chunkBase64: Buffer.from(event.chunk).toString('base64'),
+              chunkBase64,
             },
             command.sessionId,
           );
@@ -2514,7 +2821,7 @@ export async function executeStreamServerCommand(
               type: 'session-output',
               sessionId: command.sessionId,
               outputCursor: event.cursor,
-              chunkBase64: Buffer.from(event.chunk).toString('base64'),
+              chunkBase64,
               ts: new Date().toISOString(),
               directoryId: sessionState.directoryId,
               conversationId: sessionState.id,

package/src/control-plane/stream-server-session-runtime.ts

@@ -530,7 +530,8 @@ export function handleSessionEvent(
 
   const mapped = mapSessionEvent(event);
   if (mapped !== null && event.type !== 'terminal-output') {
-    const observedAt = mapped.type === 'session-exit' ? new Date().toISOString() : mapped.record.ts;
+    const nowIso = new Date().toISOString();
+    const observedAt = mapped.type === 'session-exit' ? nowIso : mapped.record.ts;
     for (const connectionId of sessionState.eventSubscriberConnectionIds) {
       ctx.sendToConnection(
         connectionId,
@@ -546,7 +547,7 @@ export function handleSessionEvent(
       type: 'session-event',
       sessionId,
       event: mapped,
-      ts: new Date().toISOString(),
+      ts: nowIso,
       directoryId: sessionState.directoryId,
       conversationId: sessionState.id,
     });