@remodex/rmx 1.0.2

package/src/android-remote/desktop-workspace-state.ts

@@ -0,0 +1,443 @@
+import { open, readFile } from "node:fs/promises";
+import { basename, join } from "node:path";
+import { getCodexHome } from "../codex/paths";
+import { resolveThreadSourcePaths } from "./thread-source-paths";
+import { boundedTurnErrorMessage } from "./turn-activity";
+
+type JsonRecord = Record<string, unknown>;
+
+export const DESKTOP_CODEX_PROJECT_ID_PREFIX = "codex-desktop-project-";
+const SESSION_ACTIVITY_SCAN_CHUNK_BYTES = 256 * 1024;
+const SESSION_ACTIVITY_SCAN_LIMIT = 50;
+const DESKTOP_RUNNING_MARKER_FRESH_MS = 30_000;
+
+export type DesktopTaskActivityOptions = {
+  now?: () => number;
+  isThreadActive?: (threadId: string) => Promise<boolean | null>;
+  runningMarkerFreshMs?: number;
+};
+
+/** The small, presentation-safe project shape exposed by Codex Desktop. */
+export type DesktopWorkspaceProject = {
+  readonly id: string;
+  readonly title: string;
+  readonly workspaceRoot: string;
+  readonly createdAt?: string;
+};
+
+export type DesktopWorkspaceSnapshot = {
+  readonly threads: JsonRecord[];
+  readonly projects: DesktopWorkspaceProject[];
+};
+
+type DesktopTaskActivity = {
+  state: "running" | "completed" | "interrupted" | "error";
+  turnId: string;
+  occurredAt: string;
+  errorMessage: string | null;
+  waitingOnUserInput: boolean;
+  pendingUserInput: DesktopPendingUserInput | null;
+};
+
+type DesktopPendingUserInput = {
+  itemId: string;
+  callId: string;
+  requestedAt: string;
+  questions: Array<{
+    id: string;
+    header: string;
+    question: string;
+    options: Array<{ label: string; description: string }>;
+    multiSelect: false;
+  }>;
+};
+
+const desktopTaskActivityCache = new Map<string, {
+  size: number;
+  activity: DesktopTaskActivity | null;
+}>();
+
+function record(value: unknown): JsonRecord | null {
+  return value && typeof value === "object" && !Array.isArray(value)
+    ? value as JsonRecord
+    : null;
+}
+
+function text(value: unknown): string {
+  return typeof value === "string" ? value.trim() : "";
+}
+
+function desktopProjectsFromState(stateValue: unknown): DesktopWorkspaceProject[] {
+  const state = record(stateValue);
+  const projects = record(state?.["local-projects"]);
+  if (!projects) return [];
+  const result: DesktopWorkspaceProject[] = [];
+  const seen = new Set<string>();
+  for (const [key, value] of Object.entries(projects)) {
+    const project = record(value);
+    if (!project) continue;
+    const id = text(project.id) || key;
+    const roots = Array.isArray(project.rootPaths)
+      ? project.rootPaths.flatMap(candidate => text(candidate) ? [text(candidate)] : [])
+      : [];
+    const workspaceRoot = roots[0] ?? "";
+    if (!id || !workspaceRoot) continue;
+    const projectId = `${DESKTOP_CODEX_PROJECT_ID_PREFIX}${id}`;
+    if (seen.has(projectId)) continue;
+    seen.add(projectId);
+    result.push({
+      id: projectId,
+      title: text(project.name) || basename(workspaceRoot),
+      workspaceRoot,
+      ...(text(project.createdAt) ? { createdAt: text(project.createdAt) } : {}),
+    });
+  }
+  return result;
+}
+
+function desktopWorkspaceSnapshotFromState(
+  threads: readonly JsonRecord[],
+  stateValue: unknown,
+): DesktopWorkspaceSnapshot {
+  const state = record(stateValue);
+  const projects = record(state?.["local-projects"]);
+  const assignments = record(state?.["thread-project-assignments"]);
+  if (!projects || !assignments) {
+    return { threads: [...threads], projects: desktopProjectsFromState(stateValue) };
+  }
+
+  const projectedThreads = threads.map(thread => {
+    const nativeThreadId = text(thread.androidRemoteNativeThreadId) || text(thread.id);
+    const assignment = record(assignments[nativeThreadId]);
+    if (text(assignment?.projectKind) !== "local") return thread;
+    const desktopProjectId = text(assignment?.projectId);
+    const project = record(projects[desktopProjectId]);
+    if (!desktopProjectId || !project) return thread;
+    const rootPaths = Array.isArray(project.rootPaths)
+      ? project.rootPaths.flatMap(value => text(value) ? [text(value)] : [])
+      : [];
+    return {
+      ...thread,
+      androidRemoteProjectId: `${DESKTOP_CODEX_PROJECT_ID_PREFIX}${desktopProjectId}`,
+      androidRemoteProjectTitle: text(project.name) || "Codex project",
+      androidRemoteProjectWorkspaceRoot: text(assignment?.cwd) || rootPaths[0] || text(thread.cwd),
+    };
+  });
+  return { threads: projectedThreads, projects: desktopProjectsFromState(stateValue) };
+}
+
+function parsedLine(line: string): JsonRecord | null {
+  let row: JsonRecord | null;
+  try {
+    row = record(JSON.parse(line));
+  } catch {
+    return null;
+  }
+  return row;
+}
+
+function activityFromRow(
+  row: JsonRecord,
+  waitingOnUserInput: boolean,
+  pendingUserInput: DesktopPendingUserInput | null,
+): DesktopTaskActivity | null {
+  if (row?.type !== "event_msg") return null;
+  const payload = record(row.payload);
+  const event = text(payload?.type);
+  const errorMessage = event === "task_complete"
+    ? boundedTurnErrorMessage(payload?.error)
+    : "";
+  const state = event === "task_started"
+    ? "running"
+    : event === "task_complete"
+      ? errorMessage ? "error" : "completed"
+      : event === "turn_aborted"
+        ? "interrupted"
+        : null;
+  if (!state) return null;
+  return {
+    state,
+    turnId: text(payload?.turn_id),
+    occurredAt: text(row.timestamp),
+    errorMessage: errorMessage || null,
+    waitingOnUserInput: state === "running" && waitingOnUserInput,
+    pendingUserInput: state === "running" && waitingOnUserInput ? pendingUserInput : null,
+  };
+}
+
+function responseCall(row: JsonRecord): {
+  type: string;
+  name: string;
+  itemId: string;
+  callId: string;
+  arguments: unknown;
+} | null {
+  if (row.type !== "response_item") return null;
+  const payload = record(row.payload);
+  if (!payload) return null;
+  return {
+    type: text(payload.type),
+    name: text(payload.name),
+    itemId: text(payload.id),
+    callId: text(payload.call_id),
+    arguments: payload.arguments,
+  };
+}
+
+function pendingUserInputFromCall(row: JsonRecord, call: NonNullable<ReturnType<typeof responseCall>>): DesktopPendingUserInput | null {
+  let args: JsonRecord | null = record(call.arguments);
+  if (!args && typeof call.arguments === "string") {
+    try { args = record(JSON.parse(call.arguments)); }
+    catch { return null; }
+  }
+  const questions = (Array.isArray(args?.questions) ? args.questions : []).flatMap(value => {
+    const question = record(value);
+    const id = text(question?.id).slice(0, 128);
+    const prompt = text(question?.question).slice(0, 2048);
+    if (!id || !prompt) return [];
+    const options = (Array.isArray(question?.options) ? question.options : []).flatMap(optionValue => {
+      const option = record(optionValue);
+      const label = text(option?.label).slice(0, 256);
+      if (!label) return [];
+      return [{
+        label,
+        description: text(option?.description).slice(0, 1024) || label,
+      }];
+    });
+    return [{
+      id,
+      header: text(question?.header).slice(0, 256) || "Question",
+      question: prompt,
+      options,
+      multiSelect: false as const,
+    }];
+  });
+  if (!call.itemId || !call.callId || questions.length === 0) return null;
+  return {
+    itemId: call.itemId.slice(0, 128),
+    callId: call.callId.slice(0, 128),
+    requestedAt: text(row.timestamp),
+    questions,
+  };
+}
+
+async function scanLatestDesktopTaskActivity(
+  file: Awaited<ReturnType<typeof open>>,
+  lowerBound: number,
+  fileSize: number,
+): Promise<DesktopTaskActivity | null> {
+  let end = fileSize;
+  let suffix = "";
+  let waitingOnUserInput = false;
+  let pendingUserInput: DesktopPendingUserInput | null = null;
+  const resolvedCallIds = new Set<string>();
+  while (end > lowerBound) {
+    const length = Math.min(SESSION_ACTIVITY_SCAN_CHUNK_BYTES, end - lowerBound);
+    const start = end - length;
+    const chunk = Buffer.allocUnsafe(length);
+    const { bytesRead } = await file.read(chunk, 0, length, start);
+    const source = chunk.subarray(0, bytesRead).toString("utf8") + suffix;
+    const lines = source.split("\n");
+    // The first line may start in the middle of a UTF-8 or JSON record.
+    const firstCompleteLine = start === lowerBound && lowerBound === 0 ? 0 : 1;
+    for (let index = lines.length - 1; index >= firstCompleteLine; index -= 1) {
+      const line = lines[index];
+      if (!line) continue;
+      const row = parsedLine(line);
+      if (!row) continue;
+      const call = responseCall(row);
+      if (call?.type === "function_call_output" && call.callId) {
+        resolvedCallIds.add(call.callId);
+      } else if (
+        call?.type === "function_call"
+        && call.name === "request_user_input"
+        && call.callId
+        && !resolvedCallIds.has(call.callId)
+      ) {
+        waitingOnUserInput = true;
+        pendingUserInput ??= pendingUserInputFromCall(row, call);
+      }
+      const activity = activityFromRow(row, waitingOnUserInput, pendingUserInput);
+      if (activity) return activity;
+    }
+    suffix = lines[0]?.slice(0, SESSION_ACTIVITY_SCAN_CHUNK_BYTES) ?? "";
+    end = start;
+  }
+  return null;
+}
+
+/** Read backwards until the most recent authoritative Desktop task marker is found. */
+async function readLatestDesktopTaskActivity(path: string): Promise<DesktopTaskActivity | null> {
+  const file = await open(path, "r");
+  try {
+    const { size } = await file.stat();
+    const cached = desktopTaskActivityCache.get(path);
+    if (cached?.size === size) return cached.activity;
+
+    // Session files are append-only. Once the current marker is known, only
+    // inspect newly appended records instead of rescanning a large transcript
+    // on every five-second shell refresh.
+    if (cached && size > cached.size) {
+      const lowerBound = Math.max(0, cached.size - 1_024);
+      const probe = Buffer.allocUnsafe(size - lowerBound);
+      const { bytesRead } = await file.read(probe, 0, probe.length, lowerBound);
+      const appendedText = probe.subarray(0, bytesRead).toString("utf8");
+      // A question changes state without emitting a task marker. Re-scan the
+      // current turn only for that rare transition so a submitted answer also
+      // clears the sidebar badge before the turn completes.
+      const questionStateChanged = appendedText.includes('"name":"request_user_input"')
+        || (cached.activity?.waitingOnUserInput === true
+          && appendedText.includes('"type":"function_call_output"'));
+      const appendedActivity = await scanLatestDesktopTaskActivity(
+        file,
+        questionStateChanged ? 0 : lowerBound,
+        size,
+      );
+      const activity = appendedActivity ?? cached.activity;
+      desktopTaskActivityCache.set(path, { size, activity });
+      return activity;
+    }
+
+    const activity = await scanLatestDesktopTaskActivity(file, 0, size);
+    desktopTaskActivityCache.set(path, { size, activity });
+    return activity;
+  } finally {
+    await file.close();
+  }
+}
+
+/**
+ * Codex's list response deliberately omits turns and reports Desktop-owned
+ * tasks as `notLoaded`. The append-only session file still carries exact
+ * task_started/task_complete markers, so project those into lightweight rows.
+ */
+export async function annotateDesktopTaskActivity(
+  threads: readonly JsonRecord[],
+  limit = SESSION_ACTIVITY_SCAN_LIMIT,
+  options: DesktopTaskActivityOptions = {},
+): Promise<JsonRecord[]> {
+  return Promise.all(threads.map(async (thread, index) => {
+    if (index >= limit) return thread;
+    try {
+      const threadId = text(thread.androidRemoteNativeThreadId) || text(thread.id);
+      const explicitPaths = [
+        text(thread.path),
+        ...(Array.isArray(thread.androidRemoteSourcePaths)
+          ? thread.androidRemoteSourcePaths.flatMap(value => {
+              const path = text(value);
+              return path ? [path] : [];
+            })
+          : []),
+      ];
+      if (!threadId || explicitPaths.length === 0) return thread;
+      const sourcePaths = await resolveThreadSourcePaths(threadId, explicitPaths, {
+        now: options.now,
+        discover: false,
+      });
+      if (sourcePaths.length === 0) return thread;
+      const activities = (
+        await Promise.all(sourcePaths.map(path => readLatestDesktopTaskActivity(path)))
+      ).flatMap(activity => activity ? [activity] : []);
+      const activity = activities
+        .map((candidate, candidateIndex) => ({
+          candidate,
+          candidateIndex,
+          timestamp: Date.parse(candidate.occurredAt),
+        }))
+        .sort((left, right) => {
+          const leftTimestamp = Number.isFinite(left.timestamp) ? left.timestamp : -Infinity;
+          const rightTimestamp = Number.isFinite(right.timestamp) ? right.timestamp : -Infinity;
+          return leftTimestamp - rightTimestamp || left.candidateIndex - right.candidateIndex;
+        })
+        .at(-1)?.candidate;
+      if (!activity) return thread;
+      if (
+        activity.state === "running"
+        && !activity.waitingOnUserInput
+        && options.isThreadActive
+        && runningMarkerIsStale(thread, activity, options)
+      ) {
+        if (threadId && await options.isThreadActive(threadId) === false) {
+          const inactive: JsonRecord = {
+            ...thread,
+            androidRemoteLatestTurnState: "interrupted",
+            androidRemoteLatestTurnId: activity.turnId,
+            androidRemoteLatestTurnAt: activity.occurredAt,
+            androidRemoteWaitingOnUserInput: false,
+          };
+          delete inactive.androidRemoteLatestTurnError;
+          delete inactive.androidRemotePendingUserInput;
+          return inactive;
+        }
+      }
+      const annotated: JsonRecord = {
+        ...thread,
+        androidRemoteLatestTurnState: activity.state,
+        androidRemoteLatestTurnId: activity.turnId,
+        androidRemoteLatestTurnAt: activity.occurredAt,
+        androidRemoteWaitingOnUserInput: activity.waitingOnUserInput,
+        ...(activity.errorMessage
+          ? { androidRemoteLatestTurnError: activity.errorMessage }
+          : {}),
+        ...(activity.pendingUserInput
+          ? { androidRemotePendingUserInput: activity.pendingUserInput }
+          : {}),
+      };
+      if (!activity.errorMessage) delete annotated.androidRemoteLatestTurnError;
+      if (!activity.pendingUserInput) delete annotated.androidRemotePendingUserInput;
+      return annotated;
+    } catch {
+      return thread;
+    }
+  }));
+}
+
+function runningMarkerIsStale(
+  thread: JsonRecord,
+  activity: DesktopTaskActivity,
+  options: DesktopTaskActivityOptions,
+): boolean {
+  const updatedAt = typeof thread.updatedAt === "number" && Number.isFinite(thread.updatedAt)
+    ? (thread.updatedAt > 10_000_000_000 ? thread.updatedAt : thread.updatedAt * 1_000)
+    : Date.parse(activity.occurredAt);
+  if (!Number.isFinite(updatedAt)) return false;
+  const freshMs = Math.max(0, options.runningMarkerFreshMs ?? DESKTOP_RUNNING_MARKER_FRESH_MS);
+  return (options.now?.() ?? Date.now()) - updatedAt >= freshMs;
+}
+
+/**
+ * Apply Codex Desktop's explicit project membership to app-server thread rows.
+ * Working-directory equality is not sufficient: projectless Chats can use the
+ * same cwd as a real project.
+ */
+export function annotateDesktopWorkspaceMembership(
+  threads: readonly JsonRecord[],
+  stateValue: unknown,
+): JsonRecord[] {
+  return desktopWorkspaceSnapshotFromState(threads, stateValue).threads;
+}
+
+/**
+ * Read Desktop's registry once and return both explicit projects (including
+ * projects with no tasks yet) and the thread membership annotations.
+ */
+export async function readDesktopWorkspaceSnapshot(
+  threads: readonly JsonRecord[],
+  codexHome = getCodexHome(),
+): Promise<DesktopWorkspaceSnapshot> {
+  try {
+    const raw = await readFile(join(codexHome, ".codex-global-state.json"), "utf8");
+    return desktopWorkspaceSnapshotFromState(threads, JSON.parse(raw));
+  } catch {
+    // Older Codex builds and non-Desktop hosts may not expose this optional
+    // state file. Keep the existing cwd projection in that case.
+    return { threads: [...threads], projects: [] };
+  }
+}
+
+export async function readDesktopWorkspaceMembership(
+  threads: readonly JsonRecord[],
+  codexHome = getCodexHome(),
+): Promise<JsonRecord[]> {
+  return (await readDesktopWorkspaceSnapshot(threads, codexHome)).threads;
+}

package/src/android-remote/file-change-parser.ts

@@ -0,0 +1,112 @@
+type JsonRecord = Record<string, unknown>;
+
+export type AndroidRemoteFileChange = {
+  path: string;
+  kind: { type: "add" | "update" | "delete" };
+  diff?: string;
+};
+
+const MAX_FILE_CHANGES = 64;
+
+function record(value: unknown): JsonRecord | null {
+  return value && typeof value === "object" && !Array.isArray(value)
+    ? value as JsonRecord
+    : null;
+}
+
+function stringValue(value: unknown): string {
+  return typeof value === "string" ? value : "";
+}
+
+function parsedArguments(payload: JsonRecord): JsonRecord {
+  const direct = record(payload.arguments);
+  if (direct) return direct;
+  const encoded = stringValue(payload.arguments);
+  if (!encoded) return {};
+  try { return record(JSON.parse(encoded)) ?? {}; }
+  catch { return {}; }
+}
+
+function decodedDoubleQuotedStrings(source: string): string[] {
+  const decoded: string[] = [];
+  const literals = /"((?:\\[\s\S]|[^"\\])*)"/gu;
+  for (const match of source.matchAll(literals)) {
+    const body = match[1];
+    if (!body || !body.includes("*** ")) continue;
+    try {
+      const value = JSON.parse(`"${body}"`);
+      if (typeof value === "string") decoded.push(value);
+    } catch {
+      // A malformed or non-JSON JavaScript string is ignored. The original
+      // source remains a candidate and can still contain a literal patch.
+    }
+  }
+  return decoded;
+}
+
+function patchSources(payload: JsonRecord): string[] {
+  const input = stringValue(payload.input);
+  const args = parsedArguments(payload);
+  const sources = [stringValue(args.patch), input].filter(Boolean);
+  if (input.includes("\\n") || input.includes('\\"')) {
+    sources.push(...decodedDoubleQuotedStrings(input));
+  }
+  return sources;
+}
+
+function dedupeKey(path: string): string {
+  // Windows treats drive-letter and network paths as case-insensitive. Keep
+  // the first spelling for display, but do not count the same file twice.
+  return /^(?:[A-Za-z]:[\\/]|\\\\)/u.test(path) ? path.toLocaleLowerCase("en-US") : path;
+}
+
+function changesFromPatchSource(source: string): AndroidRemoteFileChange[] {
+  const header = /^\*\*\* (Add|Update|Delete) File:\s*(.+?)\s*$/gmu;
+  const matches = [...source.matchAll(header)];
+  const byPath = new Map<string, AndroidRemoteFileChange>();
+
+  for (const [index, match] of matches.entries()) {
+    const operation = match[1]?.toLocaleLowerCase("en-US");
+    const path = match[2]?.trim();
+    if (!path || !["add", "update", "delete"].includes(operation ?? "")) continue;
+
+    const bodyStart = (match.index ?? 0) + match[0].length;
+    const bodyEnd = matches[index + 1]?.index ?? source.length;
+    const body = source
+      .slice(bodyStart, bodyEnd)
+      .replace(/^\*\*\* End Patch\s*$/gmu, "")
+      .trim();
+    const key = dedupeKey(path);
+    const existing = byPath.get(key);
+    const diff = [existing?.diff, body].filter(Boolean).join("\n");
+    byPath.set(key, {
+      path: existing?.path ?? path,
+      kind: existing?.kind ?? { type: operation as "add" | "update" | "delete" },
+      ...(diff ? { diff } : {}),
+    });
+  }
+
+  return [...byPath.values()];
+}
+
+/** Reads file paths and the immediately available line diff from an apply_patch call. */
+export function fileChangesFromToolCall(payload: JsonRecord): AndroidRemoteFileChange[] {
+  const name = stringValue(payload.name);
+  const input = stringValue(payload.input);
+  if (name !== "apply_patch" && !(name === "exec" && /\btools\.apply_patch\s*\(/u.test(input))) {
+    return [];
+  }
+
+  const changes: AndroidRemoteFileChange[] = [];
+  const seen = new Set<string>();
+  for (const source of patchSources(payload)) {
+    for (const change of changesFromPatchSource(source)) {
+      const key = dedupeKey(change.path);
+      if (seen.has(key)) continue;
+      seen.add(key);
+      changes.push(change);
+      if (changes.length >= MAX_FILE_CHANGES) return changes;
+    }
+  }
+  return changes;
+}