open-research-protocol 0.4.24 → 0.4.26

package/packages/orp-workspace-launcher/src/tabs.js

@@ -1,3 +1,6 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
 import process from "node:process";
 
 import {
@@ -12,6 +15,144 @@ import {
 } from "./core-plan.js";
 import { loadWorkspaceSource } from "./orp.js";
 
+const SESSION_ID_PATTERN = /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/gi;
+
+function normalizeOptionalString(value) {
+  if (value == null) {
+    return null;
+  }
+  const trimmed = String(value).trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+
+function resolveCodexHome(options = {}) {
+  return (
+    normalizeOptionalString(options.codexHome) ||
+    normalizeOptionalString(process.env.CODEX_HOME) ||
+    path.join(os.homedir(), ".codex")
+  );
+}
+
+function collectCodexSessionIds(tabs = []) {
+  return new Set(
+    tabs
+      .filter((tab) => tab.resumeTool === "codex")
+      .map((tab) => normalizeOptionalString(tab.sessionId))
+      .map((sessionId) => sessionId?.toLowerCase())
+      .filter(Boolean),
+  );
+}
+
+function sessionIdsInFilename(filename, wantedSessionIds) {
+  const matches = new Set();
+  for (const match of filename.matchAll(SESSION_ID_PATTERN)) {
+    const sessionId = match[0].toLowerCase();
+    if (wantedSessionIds.has(sessionId)) {
+      matches.add(sessionId);
+    }
+  }
+
+  if (matches.size > 0) {
+    return matches;
+  }
+
+  for (const sessionId of wantedSessionIds) {
+    if (filename.includes(sessionId)) {
+      matches.add(sessionId);
+    }
+  }
+  return matches;
+}
+
+function rememberActivity(activityBySessionId, sessionId, filePath, stat) {
+  const current = activityBySessionId.get(sessionId);
+  if (!current || stat.mtimeMs > current.mtimeMs) {
+    activityBySessionId.set(sessionId, {
+      mtimeMs: stat.mtimeMs,
+      filePath,
+    });
+  }
+}
+
+function scanActivityDirectory(rootDir, wantedSessionIds, activityBySessionId) {
+  let entries;
+  try {
+    entries = fs.readdirSync(rootDir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+
+  for (const entry of entries) {
+    const entryPath = path.join(rootDir, entry.name);
+    if (entry.isDirectory()) {
+      scanActivityDirectory(entryPath, wantedSessionIds, activityBySessionId);
+      continue;
+    }
+    if (!entry.isFile()) {
+      continue;
+    }
+
+    const matchingSessionIds = sessionIdsInFilename(entry.name, wantedSessionIds);
+    if (matchingSessionIds.size === 0) {
+      continue;
+    }
+
+    let stat;
+    try {
+      stat = fs.statSync(entryPath);
+    } catch {
+      continue;
+    }
+    for (const sessionId of matchingSessionIds) {
+      rememberActivity(activityBySessionId, sessionId, entryPath, stat);
+    }
+  }
+}
+
+function buildCodexActivityIndex(tabs = [], options = {}) {
+  const wantedSessionIds = collectCodexSessionIds(tabs);
+  if (wantedSessionIds.size === 0) {
+    return new Map();
+  }
+
+  const activityBySessionId = new Map();
+  const codexHome = resolveCodexHome(options);
+  scanActivityDirectory(path.join(codexHome, "sessions"), wantedSessionIds, activityBySessionId);
+  scanActivityDirectory(path.join(codexHome, "shell_snapshots"), wantedSessionIds, activityBySessionId);
+  return activityBySessionId;
+}
+
+function orderTabsByRecentActivity(tabs = [], options = {}) {
+  const activityBySessionId = buildCodexActivityIndex(tabs, options);
+  const rankedTabs = tabs.map((tab, originalIndex) => {
+    const sessionActivity =
+      tab.resumeTool === "codex" && tab.sessionId ? activityBySessionId.get(String(tab.sessionId).toLowerCase()) : null;
+    return {
+      tab,
+      originalIndex,
+      activityMs: sessionActivity?.mtimeMs || 0,
+    };
+  });
+
+  const projectActivity = new Map();
+  for (const ranked of rankedTabs) {
+    const current = projectActivity.get(ranked.tab.path) || 0;
+    projectActivity.set(ranked.tab.path, Math.max(current, ranked.activityMs));
+  }
+
+  return rankedTabs
+    .sort((left, right) => {
+      const leftProjectActivity = projectActivity.get(left.tab.path) || 0;
+      const rightProjectActivity = projectActivity.get(right.tab.path) || 0;
+      return (
+        rightProjectActivity - leftProjectActivity ||
+        right.activityMs - left.activityMs ||
+        left.originalIndex - right.originalIndex
+      );
+    })
+    .map((ranked) => ranked.tab);
+}
+
 export function parseWorkspaceTabsArgs(argv = []) {
   const options = {
     json: false,
@@ -64,7 +205,8 @@ export function buildWorkspaceTabsReport(source, parsed, options = {}) {
     tmux: false,
     resume: true,
   });
-  const projectGroups = buildWorkspaceProjectGroups(launchTabs);
+  const orderedLaunchTabs = orderTabsByRecentActivity(launchTabs, options);
+  const projectGroups = buildWorkspaceProjectGroups(orderedLaunchTabs);
 
   return {
     sourceType: source.sourceType,
@@ -73,7 +215,7 @@ export function buildWorkspaceTabsReport(source, parsed, options = {}) {
     workspaceId: deriveWorkspaceId(source, parsed),
     machine: parsed.manifest?.machine || null,
     parseMode: parsed.parseMode,
-    tabCount: launchTabs.length,
+    tabCount: orderedLaunchTabs.length,
     projectCount: projectGroups.length,
     skippedCount: parsed.skipped.length,
     projects: projectGroups.map((project) => ({
@@ -92,7 +234,7 @@ export function buildWorkspaceTabsReport(source, parsed, options = {}) {
         ),
       })),
     })),
-    tabs: launchTabs.map((tab, index) => ({
+    tabs: orderedLaunchTabs.map((tab, index) => ({
       index: index + 1,
       title: tab.title,
       path: tab.path,
@@ -191,7 +333,8 @@ Options:
   -h, --help              Show this help text
 
 Notes:
-  - This shows the saved tab order plus any stored local path, remote repo, bootstrap command, and \`codex resume ...\` / \`claude --resume ...\` metadata.
+  - This shows activity-ranked saved tabs plus any stored local path, remote repo, bootstrap command, and \`codex resume ...\` / \`claude --resume ...\` metadata.
+  - Codex-backed tabs are ranked by the latest matching local session or shell snapshot activity; ties keep the saved ledger order.
   - JSON output includes grouped \`projects[].sessions[]\` so duplicate project paths can be reviewed and sunset together.
   - The human-readable \`resume:\` line is already copyable and includes the saved \`cd ... && resume ...\` recovery command.
   - When a tab also has \`remote:\` or \`setup:\` lines, those are the portable cross-machine clues for cloning and preparing the repo on another rig.

package/packages/orp-workspace-launcher/test/ledger.test.js

@@ -57,6 +57,120 @@ async function withTempConfigHome(fn) {
   }
 }
 
+async function makeFakeIdeaBridgeOrpCommand(tempDir, options = {}) {
+  const scriptPath = path.join(tempDir, "fake-orp.cjs");
+  const logPath = path.join(tempDir, "orp-calls.jsonl");
+  const failCreate = options.failCreate === true;
+  const script = `#!/usr/bin/env node
+const fs = require("node:fs");
+
+const args = process.argv.slice(2);
+const logPath = process.env.FAKE_ORP_LOG;
+if (logPath) {
+  fs.appendFileSync(logPath, JSON.stringify({ args }) + "\\n", "utf8");
+}
+
+const ideaId = "idea-main-123";
+const bridgeWorkspaceId = "captured-iterm-window-20260401t032225z";
+const hostedWorkspaceId = "ws-main-cody-1";
+const failCreate = ${JSON.stringify(failCreate)};
+const baseTabs = [
+  { tab_id: "tab-orp", title: "orp", project_root: "/Volumes/Code_2TB/code/orp" },
+  { tab_id: "tab-frg", title: "frg-site", project_root: "/Volumes/Code_2TB/code/frg-site" },
+];
+
+function write(payload) {
+  process.stdout.write(JSON.stringify(payload) + "\\n");
+}
+
+function linkedIdea() {
+  return {
+    idea_id: ideaId,
+    idea_title: "Terminal paths and codex sessions 03-26-2026",
+    relationship: "primary",
+  };
+}
+
+function state(tabs) {
+  return {
+    captured_at_utc: "2026-04-15T12:00:00.000Z",
+    updated_at_utc: "2026-04-15T12:00:00.000Z",
+    tab_count: tabs.length,
+    capture_context: {
+      source_app: "test",
+      mode: "snapshot",
+      machine_id: "test-mac:darwin",
+      machine_label: "Test Mac",
+      platform: "darwin",
+    },
+    tabs,
+  };
+}
+
+function bridgeWorkspace() {
+  return {
+    workspace_id: bridgeWorkspaceId,
+    title: "Main Cody 1",
+    source_kind: "idea_bridge",
+    linked_idea: linkedIdea(),
+    state: state(baseTabs),
+  };
+}
+
+function hostedWorkspace(tabs = []) {
+  return {
+    workspace_id: hostedWorkspaceId,
+    title: "main-cody-1",
+    source_kind: "hosted",
+    linked_idea: linkedIdea(),
+    state: state(tabs),
+  };
+}
+
+if (args[0] === "workspaces" && args[1] === "list") {
+  write({ ok: true, source: "hosted", workspaces: [bridgeWorkspace()], has_more: false, cursor: "" });
+} else if (args[0] === "workspaces" && args[1] === "show") {
+  if (args[2] === bridgeWorkspaceId) {
+    write({ ok: true, workspace: bridgeWorkspace() });
+  } else if (args[2] === hostedWorkspaceId) {
+    write({ ok: true, workspace: hostedWorkspace(baseTabs) });
+  } else {
+    process.stderr.write("unknown workspace: " + args[2] + "\\n");
+    process.exit(1);
+  }
+} else if (args[0] === "workspaces" && args[1] === "add") {
+  if (failCreate) {
+    process.stderr.write("Hosted ORP returned an HTML error page instead of JSON (status=404 path=/api/cli/workspaces)\\n");
+    process.exit(1);
+  }
+  const title = args[args.indexOf("--title") + 1];
+  const linked = args[args.indexOf("--idea-id") + 1];
+  if (title !== "main-cody-1" || linked !== ideaId) {
+    process.stderr.write("unexpected add args: " + JSON.stringify(args) + "\\n");
+    process.exit(1);
+  }
+  write({ ok: true, workspace: hostedWorkspace([]) });
+} else if (args[0] === "workspaces" && args[1] === "push-state") {
+  const stateFile = args[args.indexOf("--state-file") + 1];
+  const pushedState = JSON.parse(fs.readFileSync(stateFile, "utf8"));
+  write({ ok: true, workspace: hostedWorkspace(pushedState.tabs || []) });
+} else if (args[0] === "ideas" && args[1] === "list") {
+  write({ ok: true, ideas: [], has_more: false, cursor: "" });
+} else if (args[0] === "idea" && args[1] === "update") {
+  process.stderr.write("idea update should not be called\\n");
+  process.exit(2);
+} else {
+  process.stderr.write("unexpected args: " + JSON.stringify(args) + "\\n");
+  process.exit(1);
+}
+`;
+
+  await fs.writeFile(scriptPath, script, "utf8");
+  await fs.chmod(scriptPath, 0o755);
+  await fs.writeFile(logPath, "", "utf8");
+  return { scriptPath, logPath };
+}
+
 function sampleManifest() {
   return normalizeWorkspaceManifest({
     version: "1",
@@ -326,6 +440,118 @@ test("runWorkspaceAddTab updates a local workspace manifest file", async () => {
   });
 });
 
+test("runWorkspaceAddTab promotes idea-bridge workspaces to hosted workspace state", async () => {
+  await withTempConfigHome(async (configHome) => {
+    const tempDir = await makeTempDir();
+    const { scriptPath, logPath } = await makeFakeIdeaBridgeOrpCommand(tempDir);
+    const originalLogPath = process.env.FAKE_ORP_LOG;
+    process.env.FAKE_ORP_LOG = logPath;
+
+    try {
+      const { code, stdout } = await captureStdout(() =>
+        runWorkspaceAddTab([
+          "main",
+          "--path",
+          "/Volumes/Code_2TB/code/anthropic-lab",
+          "--title",
+          "anthropic-lab",
+          "--remote-url",
+          "git@github.com:anthropic/anthropic-lab.git",
+          "--resume-tool",
+          "codex",
+          "--resume-session-id",
+          "019d4f24-c8ba-78b2-a726-48b1ce9f0fe9",
+          "--orp-command",
+          scriptPath,
+          "--json",
+        ]),
+      );
+      const payload = JSON.parse(stdout);
+      const calls = (await fs.readFile(logPath, "utf8"))
+        .trim()
+        .split("\n")
+        .filter(Boolean)
+        .map((line) => JSON.parse(line).args);
+      const slots = JSON.parse(await fs.readFile(path.join(configHome, "orp", "workspace-slots.json"), "utf8"));
+
+      assert.equal(code, 0);
+      assert.equal(payload.persistedTo, "hosted-workspace");
+      assert.equal(payload.promotedFromIdeaId, "idea-main-123");
+      assert.equal(payload.createdHostedWorkspace, true);
+      assert.equal(payload.workspaceSourceId, "ws-main-cody-1");
+      assert.equal(payload.tabCount, 3);
+      assert.equal(payload.tab.restartCommand, "cd '/Volumes/Code_2TB/code/anthropic-lab' && codex resume 019d4f24-c8ba-78b2-a726-48b1ce9f0fe9");
+      assert.equal(payload.manifest.tabs[2]?.path, "/Volumes/Code_2TB/code/anthropic-lab");
+      assert.ok(calls.some((args) => args[0] === "workspaces" && args[1] === "add"));
+      assert.ok(calls.some((args) => args[0] === "workspaces" && args[1] === "push-state"));
+      assert.equal(calls.some((args) => args[0] === "idea" && args[1] === "update"), false);
+      assert.equal(slots.slots.main.kind, "hosted-workspace");
+      assert.equal(slots.slots.main.hostedWorkspaceId, "ws-main-cody-1");
+    } finally {
+      if (originalLogPath == null) {
+        delete process.env.FAKE_ORP_LOG;
+      } else {
+        process.env.FAKE_ORP_LOG = originalLogPath;
+      }
+    }
+  });
+});
+
+test("runWorkspaceAddTab falls back to local ledger when hosted workspace creation is unavailable", async () => {
+  await withTempConfigHome(async (configHome) => {
+    const tempDir = await makeTempDir();
+    const { scriptPath, logPath } = await makeFakeIdeaBridgeOrpCommand(tempDir, { failCreate: true });
+    const originalLogPath = process.env.FAKE_ORP_LOG;
+    process.env.FAKE_ORP_LOG = logPath;
+
+    try {
+      const { code, stdout } = await captureStdout(() =>
+        runWorkspaceAddTab([
+          "main",
+          "--path",
+          "/Volumes/Code_2TB/code/anthropic-lab",
+          "--title",
+          "anthropic-lab",
+          "--remote-url",
+          "git@github.com:anthropic/anthropic-lab.git",
+          "--resume-tool",
+          "codex",
+          "--resume-session-id",
+          "019d4f24-c8ba-78b2-a726-48b1ce9f0fe9",
+          "--orp-command",
+          scriptPath,
+          "--json",
+        ]),
+      );
+      const payload = JSON.parse(stdout);
+      const calls = (await fs.readFile(logPath, "utf8"))
+        .trim()
+        .split("\n")
+        .filter(Boolean)
+        .map((line) => JSON.parse(line).args);
+      const saved = JSON.parse(await fs.readFile(payload.manifestPath, "utf8"));
+      const slots = JSON.parse(await fs.readFile(path.join(configHome, "orp", "workspace-slots.json"), "utf8"));
+
+      assert.equal(code, 0);
+      assert.equal(payload.persistedTo, "workspace-file");
+      assert.equal(payload.promotedFromIdeaId, "idea-main-123");
+      assert.match(payload.hostedMigrationSkippedReason, /status=404/);
+      assert.equal(payload.tabCount, 3);
+      assert.equal(saved.tabs[2]?.path, "/Volumes/Code_2TB/code/anthropic-lab");
+      assert.ok(calls.some((args) => args[0] === "workspaces" && args[1] === "add"));
+      assert.equal(calls.some((args) => args[0] === "idea" && args[1] === "update"), false);
+      assert.equal(slots.slots.main.kind, "workspace-file");
+      assert.equal(slots.slots.main.manifestPath, payload.manifestPath);
+    } finally {
+      if (originalLogPath == null) {
+        delete process.env.FAKE_ORP_LOG;
+      } else {
+        process.env.FAKE_ORP_LOG = originalLogPath;
+      }
+    }
+  });
+});
+
 test("runWorkspaceAddTab upserts an existing tab and returns the rendered recovery command", async () => {
   await withTempConfigHome(async () => {
     const tempDir = await makeTempDir();

package/packages/orp-workspace-launcher/test/tabs.test.js

@@ -123,6 +123,66 @@ test("buildWorkspaceTabsReport keeps duplicate titles unique and exposes generic
   assert.equal(report.tabs[2]?.codexSessionId, null);
 });
 
+test("buildWorkspaceTabsReport ranks Codex tabs by recent local session activity", async () => {
+  const tempDir = await makeTempDir();
+  const codexHome = path.join(tempDir, "codex-home");
+  const sessionsDir = path.join(codexHome, "sessions", "2026", "04", "15");
+  await fs.mkdir(sessionsDir, { recursive: true });
+
+  const olderSessionId = "019d0000-0000-7000-8000-000000000001";
+  const newerSessionId = "019d0000-0000-7000-8000-000000000002";
+  const olderPath = path.join(sessionsDir, `rollout-2026-04-15T01-00-00-${olderSessionId}.jsonl`);
+  const newerPath = path.join(sessionsDir, `rollout-2026-04-15T02-00-00-${newerSessionId}.jsonl`);
+  await fs.writeFile(olderPath, "{}\n", "utf8");
+  await fs.writeFile(newerPath, "{}\n", "utf8");
+  await fs.utimes(olderPath, new Date("2026-04-15T01:00:00Z"), new Date("2026-04-15T01:00:00Z"));
+  await fs.utimes(newerPath, new Date("2026-04-15T02:00:00Z"), new Date("2026-04-15T02:00:00Z"));
+
+  const parsed = parseWorkspaceSource({
+    sourceType: "workspace-file",
+    sourceLabel: "/tmp/workspace.json",
+    title: "workspace",
+    workspaceManifest: {
+      version: "1",
+      workspaceId: "orp-main",
+      tabs: [
+        {
+          title: "older-project",
+          path: "/Volumes/Code_2TB/code/older-project",
+          resumeCommand: `codex resume ${olderSessionId}`,
+        },
+        {
+          title: "no-session-project",
+          path: "/Volumes/Code_2TB/code/no-session-project",
+        },
+        {
+          title: "newer-project",
+          path: "/Volumes/Code_2TB/code/newer-project",
+          resumeCommand: `codex resume ${newerSessionId}`,
+        },
+      ],
+    },
+    notes: "",
+  });
+
+  const report = buildWorkspaceTabsReport(
+    {
+      sourceType: "workspace-file",
+      sourceLabel: "/tmp/workspace.json",
+      title: "workspace",
+    },
+    parsed,
+    { codexHome },
+  );
+
+  assert.equal(report.tabs[0]?.title, "newer-project");
+  assert.equal(report.tabs[1]?.title, "older-project");
+  assert.equal(report.tabs[2]?.title, "no-session-project");
+  assert.equal(report.projects[0]?.path, "/Volumes/Code_2TB/code/newer-project");
+  assert.equal(report.projects[1]?.path, "/Volumes/Code_2TB/code/older-project");
+  assert.equal(report.projects[2]?.path, "/Volumes/Code_2TB/code/no-session-project");
+});
+
 test("runWorkspaceTabs prints JSON without launch commands", async () => {
   const tempDir = await makeTempDir();
   const manifestPath = path.join(tempDir, "workspace.json");