work-ally 0.2.0-alpha.1

package/bridge/src/work-session-store.ts

@@ -0,0 +1,471 @@
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import {
+  conversationKey,
+  ensureDir,
+  nowIso,
+  randomId,
+  readJsonFile,
+  sanitizeSegment,
+  writeJsonFile,
+} from './utils.ts';
+import type {
+  WorkSessionActiveSurface,
+  WorkSessionAssistantIndex,
+  WorkSessionCliResumeRefType,
+  WorkSessionDeliveryIndex,
+  WorkSessionMeta,
+  WorkSessionOrigin,
+  WorkSessionOwnershipSource,
+  WorkSessionResumeCapability,
+} from './types.ts';
+
+interface CreateWorkSessionInput {
+  workSessionId?: string;
+  threadHandle?: string | null;
+  assistantName: string;
+  assistantCodexHome?: string | null;
+  workspaceRoot: string;
+  runtimeThreadId: string;
+  cliResumeRef?: string | null;
+  cliResumeRefType?: WorkSessionCliResumeRefType;
+  threadName?: string | null;
+  origin: WorkSessionOrigin;
+  deliveryChannel?: string | null;
+  deliveryConversationKey?: string | null;
+  activeSurface: WorkSessionActiveSurface;
+  ownershipSource: WorkSessionOwnershipSource;
+  resumeCapability?: WorkSessionResumeCapability;
+  lastRuntimeActivityAt?: string | null;
+  lastSurfaceSwitchAt?: string;
+  createdAt?: string;
+  updatedAt?: string;
+  archivedAt?: string | null;
+  lastTurnId?: string | null;
+  lastPromptPreview?: string | null;
+  lastReplyPreview?: string | null;
+  lastHandoffExportAt?: string | null;
+  lastAttachAt?: string | null;
+}
+
+type WorkSessionUpdate = Partial<Omit<WorkSessionMeta,
+  'workSessionId'
+  | 'threadHandle'
+  | 'assistantName'
+  | 'assistantCodexHome'
+  | 'workspaceRoot'
+  | 'runtime'
+  | 'runtimeThreadId'
+  | 'createdAt'
+>>;
+
+function normalizeNullableText(value: string | null | undefined): string | null {
+  if (value === undefined || value === null) {
+    return null;
+  }
+  const trimmed = String(value).trim();
+  return trimmed || null;
+}
+
+function normalizeThreadHandle(value: string | null | undefined): string | null {
+  const normalized = normalizeNullableText(value)?.toLowerCase() || null;
+  if (!normalized) {
+    return null;
+  }
+  if (!/^[a-z0-9][a-z0-9-]{2,31}$/.test(normalized)) {
+    return null;
+  }
+  return normalized;
+}
+
+function ensureDeliveryBinding(channel: string | null, key: string | null): void {
+  if ((channel && !key) || (!channel && key)) {
+    throw new Error('deliveryChannel and deliveryConversationKey must be set together');
+  }
+}
+
+function resolveResumeCapability(
+  requested: WorkSessionResumeCapability | undefined,
+  cliResumeRef: string | null,
+): WorkSessionResumeCapability {
+  if (requested === 'ready' && !cliResumeRef) {
+    throw new Error('resumeCapability=ready requires cliResumeRef');
+  }
+  if (requested) {
+    return requested;
+  }
+  return cliResumeRef ? 'ready' : 'not_ready';
+}
+
+export class WorkSessionStore {
+  private readonly rootDir: string;
+
+  constructor(rootDir: string) {
+    this.rootDir = ensureDir(rootDir);
+    ensureDir(path.join(this.rootDir, 'objects'));
+    ensureDir(path.join(this.rootDir, 'indexes', 'assistants'));
+    ensureDir(path.join(this.rootDir, 'indexes', 'deliveries'));
+  }
+
+  private workSessionDir(workSessionId: string): string {
+    return path.join(this.rootDir, 'objects', sanitizeSegment(workSessionId));
+  }
+
+  private metaFile(workSessionId: string): string {
+    return path.join(this.workSessionDir(workSessionId), 'meta.json');
+  }
+
+  private assistantIndexFile(assistantName: string): string {
+    return path.join(this.rootDir, 'indexes', 'assistants', `${sanitizeSegment(assistantName)}.json`);
+  }
+
+  private deliveryIndexFile(deliveryChannel: string, deliveryConversationKey: string): string {
+    return path.join(this.rootDir, 'indexes', 'deliveries', `${conversationKey(deliveryChannel, deliveryConversationKey)}.json`);
+  }
+
+  private listRawWorkSessions(): WorkSessionMeta[] {
+    const objectsDir = path.join(this.rootDir, 'objects');
+    if (!fs.existsSync(objectsDir)) {
+      return [];
+    }
+    return fs.readdirSync(objectsDir, { withFileTypes: true })
+      .filter((entry) => entry.isDirectory())
+      .map((entry) => readJsonFile(path.join(objectsDir, entry.name, 'meta.json')) as WorkSessionMeta | null)
+      .filter((entry): entry is WorkSessionMeta => Boolean(entry));
+  }
+
+  private threadHandleOwner(assistantName: string, threadHandle: string): string | null {
+    for (const item of this.listRawWorkSessions()) {
+      if (item.assistantName !== assistantName) {
+        continue;
+      }
+      if (normalizeThreadHandle(item.threadHandle) === threadHandle) {
+        return item.workSessionId;
+      }
+    }
+    return null;
+  }
+
+  private generateThreadHandle(assistantName: string, workSessionId: string, preferred?: string | null): string {
+    const normalizedPreferred = normalizeThreadHandle(preferred);
+    if (normalizedPreferred) {
+      const owner = this.threadHandleOwner(assistantName, normalizedPreferred);
+      if (!owner || owner === workSessionId) {
+        return normalizedPreferred;
+      }
+    }
+
+    const digest = crypto.createHash('sha1').update(`${assistantName}:${workSessionId}`).digest('hex');
+    for (const length of [7, 9, 11, 13]) {
+      const candidate = `t${digest.slice(0, length)}`;
+      const owner = this.threadHandleOwner(assistantName, candidate);
+      if (!owner || owner === workSessionId) {
+        return candidate;
+      }
+    }
+
+    for (let counter = 1; counter < 1000; counter += 1) {
+      const candidate = `t${digest.slice(0, 10)}-${counter}`;
+      const owner = this.threadHandleOwner(assistantName, candidate);
+      if (!owner || owner === workSessionId) {
+        return candidate;
+      }
+    }
+
+    throw new Error(`unable to generate unique threadHandle for assistant ${assistantName}`);
+  }
+
+  private normalizeLoadedMeta(raw: WorkSessionMeta | null): WorkSessionMeta | null {
+    if (!raw) {
+      return null;
+    }
+    const expectedHandle = this.generateThreadHandle(raw.assistantName, raw.workSessionId, raw.threadHandle);
+    if (raw.threadHandle === expectedHandle) {
+      return raw;
+    }
+    const next: WorkSessionMeta = {
+      ...raw,
+      threadHandle: expectedHandle,
+    };
+    this.writeMeta(next);
+    return next;
+  }
+
+  private normalizeCreateInput(input: CreateWorkSessionInput): WorkSessionMeta {
+    const workSessionId = normalizeNullableText(input.workSessionId) || randomId('work_session');
+    const assistantName = normalizeNullableText(input.assistantName);
+    const workspaceRoot = normalizeNullableText(input.workspaceRoot);
+    const runtimeThreadId = normalizeNullableText(input.runtimeThreadId);
+    const cliResumeRef = normalizeNullableText(input.cliResumeRef);
+    const assistantCodexHome = normalizeNullableText(input.assistantCodexHome);
+    const deliveryChannel = normalizeNullableText(input.deliveryChannel);
+    const deliveryConversationKey = normalizeNullableText(input.deliveryConversationKey);
+    ensureDeliveryBinding(deliveryChannel, deliveryConversationKey);
+    if (!assistantName) {
+      throw new Error('assistantName is required');
+    }
+    if (!workspaceRoot) {
+      throw new Error('workspaceRoot is required');
+    }
+    if (!runtimeThreadId) {
+      throw new Error('runtimeThreadId is required');
+    }
+    const createdAt = input.createdAt || nowIso();
+    const updatedAt = input.updatedAt || createdAt;
+    return {
+      workSessionId,
+      threadHandle: this.generateThreadHandle(assistantName, workSessionId, input.threadHandle),
+      assistantName,
+      assistantCodexHome,
+      workspaceRoot,
+      runtime: 'codex',
+      runtimeThreadId,
+      cliResumeRef,
+      cliResumeRefType: input.cliResumeRefType || (cliResumeRef ? 'unknown' : 'null'),
+      threadName: normalizeNullableText(input.threadName),
+      origin: input.origin,
+      deliveryChannel,
+      deliveryConversationKey,
+      activeSurface: input.activeSurface,
+      ownershipSource: input.ownershipSource,
+      resumeCapability: resolveResumeCapability(input.resumeCapability, cliResumeRef),
+      lastRuntimeActivityAt: normalizeNullableText(input.lastRuntimeActivityAt),
+      lastSurfaceSwitchAt: input.lastSurfaceSwitchAt || updatedAt,
+      createdAt,
+      updatedAt,
+      archivedAt: normalizeNullableText(input.archivedAt),
+      lastTurnId: normalizeNullableText(input.lastTurnId),
+      lastPromptPreview: normalizeNullableText(input.lastPromptPreview),
+      lastReplyPreview: normalizeNullableText(input.lastReplyPreview),
+      lastHandoffExportAt: normalizeNullableText(input.lastHandoffExportAt),
+      lastAttachAt: normalizeNullableText(input.lastAttachAt),
+    };
+  }
+
+  private writeMeta(meta: WorkSessionMeta): void {
+    writeJsonFile(this.metaFile(meta.workSessionId), meta);
+  }
+
+  private loadAssistantIndex(assistantName: string): WorkSessionAssistantIndex | null {
+    return readJsonFile(this.assistantIndexFile(assistantName)) as WorkSessionAssistantIndex | null;
+  }
+
+  private loadDeliveryIndex(deliveryChannel: string, deliveryConversationKey: string): WorkSessionDeliveryIndex | null {
+    return readJsonFile(this.deliveryIndexFile(deliveryChannel, deliveryConversationKey)) as WorkSessionDeliveryIndex | null;
+  }
+
+  createWorkSession(input: CreateWorkSessionInput): WorkSessionMeta {
+    const meta = this.normalizeCreateInput(input);
+    if (this.getWorkSession(meta.workSessionId)) {
+      throw new Error(`work_session already exists: ${meta.workSessionId}`);
+    }
+    this.writeMeta(meta);
+    this.setAssistantActiveWorkSession(meta.assistantName, meta.workSessionId, meta.updatedAt);
+    if (meta.deliveryChannel && meta.deliveryConversationKey) {
+      this.setDeliveryActiveWorkSession(meta.deliveryChannel, meta.deliveryConversationKey, meta.workSessionId, meta.updatedAt);
+    }
+    return meta;
+  }
+
+  getWorkSession(workSessionId: string): WorkSessionMeta | null {
+    return this.normalizeLoadedMeta(readJsonFile(this.metaFile(workSessionId)) as WorkSessionMeta | null);
+  }
+
+  listWorkSessions(): WorkSessionMeta[] {
+    return this.listRawWorkSessions()
+      .map((entry) => this.normalizeLoadedMeta(entry))
+      .filter((entry): entry is WorkSessionMeta => Boolean(entry))
+      .sort((left, right) => String(right.updatedAt).localeCompare(String(left.updatedAt)));
+  }
+
+  listWorkSessionsForAssistant(assistantName: string, options: { includeArchived?: boolean } = {}): WorkSessionMeta[] {
+    return this.listWorkSessions().filter((item) => (
+      item.assistantName === assistantName
+      && (options.includeArchived ? true : !item.archivedAt)
+    ));
+  }
+
+  findWorkSessionByThreadHandle(assistantName: string, threadHandle: string): WorkSessionMeta | null {
+    const normalized = normalizeThreadHandle(threadHandle);
+    if (!normalized) {
+      return null;
+    }
+    return this.listWorkSessionsForAssistant(assistantName, { includeArchived: true })
+      .find((item) => item.threadHandle === normalized) || null;
+  }
+
+  rebindRuntimeThread(workSessionId: string, runtimeThreadId: string, updatedAt = nowIso()): WorkSessionMeta {
+    const current = this.getWorkSession(workSessionId);
+    if (!current) {
+      throw new Error(`work_session not found: ${workSessionId}`);
+    }
+    const nextRuntimeThreadId = normalizeNullableText(runtimeThreadId);
+    if (!nextRuntimeThreadId) {
+      throw new Error('runtimeThreadId is required');
+    }
+    if (current.runtimeThreadId === nextRuntimeThreadId) {
+      return current;
+    }
+
+    const shouldFollowRuntimeThread = (
+      current.cliResumeRefType === 'session_id'
+      && (!current.cliResumeRef || current.cliResumeRef === current.runtimeThreadId)
+    );
+    const nextCliResumeRef = shouldFollowRuntimeThread ? nextRuntimeThreadId : current.cliResumeRef;
+    const nextCliResumeRefType = shouldFollowRuntimeThread ? 'session_id' : current.cliResumeRefType;
+    const nextResumeCapability = resolveResumeCapability(
+      shouldFollowRuntimeThread ? 'ready' : current.resumeCapability,
+      nextCliResumeRef,
+    );
+
+    const next: WorkSessionMeta = {
+      ...current,
+      runtimeThreadId: nextRuntimeThreadId,
+      cliResumeRef: nextCliResumeRef,
+      cliResumeRefType: nextCliResumeRefType,
+      resumeCapability: nextResumeCapability,
+      updatedAt,
+    };
+    this.writeMeta(next);
+    return next;
+  }
+
+  updateWorkSession(workSessionId: string, patch: WorkSessionUpdate): WorkSessionMeta {
+    const current = this.getWorkSession(workSessionId);
+    if (!current) {
+      throw new Error(`work_session not found: ${workSessionId}`);
+    }
+    if ('activeSurface' in patch !== 'ownershipSource' in patch) {
+      throw new Error('activeSurface and ownershipSource must be updated together');
+    }
+
+    const nextDeliveryChannel = 'deliveryChannel' in patch
+      ? normalizeNullableText(patch.deliveryChannel)
+      : current.deliveryChannel;
+    const nextDeliveryConversationKey = 'deliveryConversationKey' in patch
+      ? normalizeNullableText(patch.deliveryConversationKey)
+      : current.deliveryConversationKey;
+    ensureDeliveryBinding(nextDeliveryChannel, nextDeliveryConversationKey);
+    if (current.deliveryChannel && current.deliveryConversationKey) {
+      if (nextDeliveryChannel !== current.deliveryChannel || nextDeliveryConversationKey !== current.deliveryConversationKey) {
+        throw new Error('delivery binding is immutable once linked');
+      }
+    }
+
+    const nextCliResumeRef = 'cliResumeRef' in patch
+      ? normalizeNullableText(patch.cliResumeRef)
+      : current.cliResumeRef;
+    const nextResumeCapability = resolveResumeCapability(patch.resumeCapability, nextCliResumeRef);
+    const updatedAt = patch.updatedAt || nowIso();
+    const next: WorkSessionMeta = {
+      ...current,
+      ...patch,
+      cliResumeRef: nextCliResumeRef,
+      deliveryChannel: nextDeliveryChannel,
+      deliveryConversationKey: nextDeliveryConversationKey,
+      resumeCapability: nextResumeCapability,
+      updatedAt,
+    };
+    this.writeMeta(next);
+    return next;
+  }
+
+  bindDeliveryWorkSession(
+    workSessionId: string,
+    deliveryChannel: string,
+    deliveryConversationKey: string,
+    updatedAt = nowIso(),
+  ): WorkSessionMeta {
+    const current = this.getWorkSession(workSessionId);
+    if (!current) {
+      throw new Error(`work_session not found: ${workSessionId}`);
+    }
+    if (current.deliveryChannel === deliveryChannel && current.deliveryConversationKey === deliveryConversationKey) {
+      this.setDeliveryActiveWorkSession(deliveryChannel, deliveryConversationKey, current.workSessionId, updatedAt);
+      return current;
+    }
+
+    const previousChannel = current.deliveryChannel;
+    const previousConversationKey = current.deliveryConversationKey;
+    const next: WorkSessionMeta = {
+      ...current,
+      deliveryChannel,
+      deliveryConversationKey,
+      updatedAt,
+    };
+    this.writeMeta(next);
+
+    if (previousChannel && previousConversationKey) {
+      const previousIndex = this.getDeliveryIndex(previousChannel, previousConversationKey);
+      if (previousIndex?.activeWorkSessionId === current.workSessionId) {
+        this.setDeliveryActiveWorkSession(previousChannel, previousConversationKey, null, updatedAt);
+      }
+    }
+
+    this.setDeliveryActiveWorkSession(deliveryChannel, deliveryConversationKey, next.workSessionId, updatedAt);
+    return next;
+  }
+
+  getAssistantIndex(assistantName: string): WorkSessionAssistantIndex | null {
+    return this.loadAssistantIndex(assistantName);
+  }
+
+  getActiveWorkSessionForAssistant(assistantName: string): WorkSessionMeta | null {
+    const index = this.loadAssistantIndex(assistantName);
+    return index?.activeWorkSessionId ? this.getWorkSession(index.activeWorkSessionId) : null;
+  }
+
+  setAssistantActiveWorkSession(assistantName: string, workSessionId: string | null, updatedAt = nowIso()): WorkSessionAssistantIndex {
+    if (workSessionId) {
+      const meta = this.getWorkSession(workSessionId);
+      if (!meta) {
+        throw new Error(`work_session not found: ${workSessionId}`);
+      }
+      if (meta.assistantName !== assistantName) {
+        throw new Error('assistant index cannot point to another assistant\'s work_session');
+      }
+    }
+    const index: WorkSessionAssistantIndex = {
+      assistantName,
+      activeWorkSessionId: workSessionId,
+      updatedAt,
+    };
+    writeJsonFile(this.assistantIndexFile(assistantName), index);
+    return index;
+  }
+
+  getDeliveryIndex(deliveryChannel: string, deliveryConversationKey: string): WorkSessionDeliveryIndex | null {
+    return this.loadDeliveryIndex(deliveryChannel, deliveryConversationKey);
+  }
+
+  getActiveWorkSessionForDelivery(deliveryChannel: string, deliveryConversationKey: string): WorkSessionMeta | null {
+    const index = this.loadDeliveryIndex(deliveryChannel, deliveryConversationKey);
+    return index?.activeWorkSessionId ? this.getWorkSession(index.activeWorkSessionId) : null;
+  }
+
+  setDeliveryActiveWorkSession(
+    deliveryChannel: string,
+    deliveryConversationKey: string,
+    workSessionId: string | null,
+    updatedAt = nowIso(),
+  ): WorkSessionDeliveryIndex {
+    if (workSessionId) {
+      const meta = this.getWorkSession(workSessionId);
+      if (!meta) {
+        throw new Error(`work_session not found: ${workSessionId}`);
+      }
+      if (meta.deliveryChannel !== deliveryChannel || meta.deliveryConversationKey !== deliveryConversationKey) {
+        throw new Error('delivery index cannot point to an unlinked work_session');
+      }
+    }
+    const index: WorkSessionDeliveryIndex = {
+      deliveryChannel,
+      deliveryConversationKey,
+      activeWorkSessionId: workSessionId,
+      updatedAt,
+    };
+    writeJsonFile(this.deliveryIndexFile(deliveryChannel, deliveryConversationKey), index);
+    return index;
+  }
+}