open-research-protocol 0.4.13 → 0.4.15

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

@@ -0,0 +1,244 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+
+import {
+  addTabToManifest,
+  normalizeWorkspaceManifest,
+  parseWorkspaceCreateArgs,
+  parseWorkspaceAddTabArgs,
+  parseWorkspaceRemoveTabArgs,
+  removeTabsFromManifest,
+  runWorkspaceCreate,
+  runWorkspaceAddTab,
+  runWorkspaceRemoveTab,
+} from "../src/index.js";
+
+async function makeTempDir() {
+  return fs.mkdtemp(path.join(os.tmpdir(), "orp-workspace-ledger-"));
+}
+
+async function captureStdout(fn) {
+  const chunks = [];
+  const originalWrite = process.stdout.write;
+  process.stdout.write = (chunk, encoding, callback) => {
+    chunks.push(typeof chunk === "string" ? chunk : chunk.toString(encoding || "utf8"));
+    if (typeof callback === "function") {
+      callback();
+    }
+    return true;
+  };
+
+  try {
+    const code = await fn();
+    return {
+      code,
+      stdout: chunks.join(""),
+    };
+  } finally {
+    process.stdout.write = originalWrite;
+  }
+}
+
+async function withTempConfigHome(fn) {
+  const tempDir = await makeTempDir();
+  const original = process.env.XDG_CONFIG_HOME;
+  process.env.XDG_CONFIG_HOME = tempDir;
+  try {
+    return await fn(tempDir);
+  } finally {
+    if (original == null) {
+      delete process.env.XDG_CONFIG_HOME;
+    } else {
+      process.env.XDG_CONFIG_HOME = original;
+    }
+  }
+}
+
+function sampleManifest() {
+  return normalizeWorkspaceManifest({
+    version: "1",
+    workspaceId: "main-cody-1",
+    title: "main-cody-1",
+    tabs: [
+      {
+        title: "orp",
+        path: "/Volumes/Code_2TB/code/orp",
+      },
+      {
+        title: "frg-site",
+        path: "/Volumes/Code_2TB/code/frg-site",
+        resumeCommand: "codex resume 019d348d-5031-78e1-9840-a66deaac33ae",
+        resumeTool: "codex",
+        resumeSessionId: "019d348d-5031-78e1-9840-a66deaac33ae",
+      },
+    ],
+  });
+}
+
+test("parseWorkspaceAddTabArgs accepts explicit resume metadata", () => {
+  const parsed = parseWorkspaceAddTabArgs([
+    "main",
+    "--path",
+    "/Volumes/Code_2TB/code/new-project",
+    "--resume-tool",
+    "claude",
+    "--resume-session-id",
+    "claude-456",
+    "--json",
+  ]);
+
+  assert.equal(parsed.ideaId, "main");
+  assert.equal(parsed.path, "/Volumes/Code_2TB/code/new-project");
+  assert.equal(parsed.resumeTool, "claude");
+  assert.equal(parsed.resumeSessionId, "claude-456");
+  assert.equal(parsed.json, true);
+});
+
+test("parseWorkspaceCreateArgs validates slug titles and optional seed metadata", () => {
+  const parsed = parseWorkspaceCreateArgs([
+    "main-cody-1",
+    "--slot",
+    "main",
+    "--path",
+    "/Volumes/Code_2TB/code/orp",
+    "--resume-tool",
+    "claude",
+    "--resume-session-id",
+    "claude-456",
+    "--json",
+  ]);
+
+  assert.equal(parsed.title, "main-cody-1");
+  assert.equal(parsed.slotName, "main");
+  assert.equal(parsed.path, "/Volumes/Code_2TB/code/orp");
+  assert.equal(parsed.resumeTool, "claude");
+  assert.equal(parsed.resumeSessionId, "claude-456");
+  assert.equal(parsed.json, true);
+  assert.throws(() => parseWorkspaceCreateArgs(["Main Cody"]), /workspace title/);
+});
+
+test("parseWorkspaceRemoveTabArgs requires a matching selector", () => {
+  assert.throws(
+    () => parseWorkspaceRemoveTabArgs(["main"]),
+    /Provide at least one selector/,
+  );
+});
+
+test("addTabToManifest canonicalizes Claude resume commands from tool plus session id", () => {
+  const result = addTabToManifest(sampleManifest(), {
+    path: "/Volumes/Code_2TB/code/anthropic-lab",
+    title: "anthropic-lab",
+    resumeTool: "claude",
+    resumeSessionId: "claude-456",
+  });
+
+  assert.equal(result.added, true);
+  assert.equal(result.manifest.tabs.length, 3);
+  assert.equal(result.manifest.tabs[2]?.path, "/Volumes/Code_2TB/code/anthropic-lab");
+  assert.equal(result.manifest.tabs[2]?.title, "anthropic-lab");
+  assert.equal(result.manifest.tabs[2]?.resumeCommand, "claude --resume claude-456");
+  assert.equal(result.manifest.tabs[2]?.resumeTool, "claude");
+  assert.equal(result.manifest.tabs[2]?.sessionId, "claude-456");
+});
+
+test("removeTabsFromManifest can target a saved tab by path and resume session id", () => {
+  const result = removeTabsFromManifest(sampleManifest(), {
+    path: "/Volumes/Code_2TB/code/frg-site",
+    resumeSessionId: "019d348d-5031-78e1-9840-a66deaac33ae",
+  });
+
+  assert.equal(result.manifest.tabs.length, 1);
+  assert.equal(result.removedTabs.length, 1);
+  assert.equal(result.removedTabs[0]?.path, "/Volumes/Code_2TB/code/frg-site");
+});
+
+test("runWorkspaceAddTab updates a local workspace manifest file", async () => {
+  await withTempConfigHome(async () => {
+    const tempDir = await makeTempDir();
+    const manifestPath = path.join(tempDir, "workspace.json");
+    await fs.writeFile(manifestPath, `${JSON.stringify(sampleManifest(), null, 2)}\n`, "utf8");
+
+    const { code, stdout } = await captureStdout(() =>
+      runWorkspaceAddTab([
+        "--workspace-file",
+        manifestPath,
+        "--path",
+        "/Volumes/Code_2TB/code/anthropic-lab",
+        "--resume-tool",
+        "claude",
+        "--resume-session-id",
+        "claude-456",
+        "--json",
+      ]),
+    );
+    const payload = JSON.parse(stdout);
+    const saved = JSON.parse(await fs.readFile(manifestPath, "utf8"));
+
+    assert.equal(code, 0);
+    assert.equal(payload.action, "add-tab");
+    assert.equal(payload.tabCount, 3);
+    assert.equal(payload.tab.resumeCommand, "claude --resume claude-456");
+    assert.equal(saved.tabs.length, 3);
+    assert.equal(saved.tabs[2]?.resumeCommand, "claude --resume claude-456");
+  });
+});
+
+test("runWorkspaceRemoveTab updates a local workspace manifest file", async () => {
+  await withTempConfigHome(async () => {
+    const tempDir = await makeTempDir();
+    const manifestPath = path.join(tempDir, "workspace.json");
+    await fs.writeFile(manifestPath, `${JSON.stringify(sampleManifest(), null, 2)}\n`, "utf8");
+
+    const { code, stdout } = await captureStdout(() =>
+      runWorkspaceRemoveTab([
+        "--workspace-file",
+        manifestPath,
+        "--path",
+        "/Volumes/Code_2TB/code/frg-site",
+        "--resume-session-id",
+        "019d348d-5031-78e1-9840-a66deaac33ae",
+        "--json",
+      ]),
+    );
+    const payload = JSON.parse(stdout);
+    const saved = JSON.parse(await fs.readFile(manifestPath, "utf8"));
+
+    assert.equal(code, 0);
+    assert.equal(payload.action, "remove-tab");
+    assert.equal(payload.tabCount, 1);
+    assert.equal(payload.removedTabs.length, 1);
+    assert.equal(saved.tabs.length, 1);
+    assert.equal(saved.tabs[0]?.path, "/Volumes/Code_2TB/code/orp");
+  });
+});
+
+test("runWorkspaceCreate creates a local managed workspace and auto-assigns main when it is the first one", async () => {
+  await withTempConfigHome(async (configHome) => {
+    const { code, stdout } = await captureStdout(() =>
+      runWorkspaceCreate([
+        "main-cody-1",
+        "--path",
+        "/Volumes/Code_2TB/code/orp",
+        "--resume-tool",
+        "claude",
+        "--resume-session-id",
+        "claude-456",
+        "--json",
+      ]),
+    );
+    const payload = JSON.parse(stdout);
+    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.action, "create");
+    assert.equal(payload.workspaceTitle, "main-cody-1");
+    assert.equal(payload.tabCount, 1);
+    assert.equal(saved.title, "main-cody-1");
+    assert.equal(saved.tabs[0]?.resumeCommand, "claude --resume claude-456");
+    assert.equal(slots.slots.main.title, "main-cody-1");
+  });
+});

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

@@ -0,0 +1,299 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+
+import {
+  applyWorkspaceSlotsToInventory,
+  buildWorkspaceInventory,
+  cacheManagedWorkspaceManifest,
+  getManagedWorkspaceDir,
+  listTrackedWorkspaces,
+  loadWorkspaceSlots,
+  parseWorkspaceListArgs,
+  registerWorkspaceManifest,
+  setWorkspaceSlot,
+  summarizeTrackedWorkspaces,
+  summarizeWorkspaceInventory,
+} from "../src/index.js";
+
+async function makeTempDir() {
+  return fs.mkdtemp(path.join(os.tmpdir(), "orp-workspace-list-"));
+}
+
+test("parseWorkspaceListArgs accepts --json", () => {
+  const parsed = parseWorkspaceListArgs(["--json"]);
+  assert.equal(parsed.json, true);
+  assert.throws(() => parseWorkspaceListArgs(["--wat"]), /unexpected argument/);
+});
+
+test("registerWorkspaceManifest and listTrackedWorkspaces expose tracked saved resume commands", async () => {
+  const tempDir = await makeTempDir();
+  const env = {
+    ...process.env,
+    XDG_CONFIG_HOME: path.join(tempDir, "config"),
+  };
+  const manifestPath = path.join(tempDir, "workspace.json");
+  const manifest = {
+    version: "1",
+    workspaceId: "orp-main",
+    title: "ORP Main",
+    capture: {
+      sourceApp: "iTerm",
+      mode: "watch",
+      host: "local-macbook",
+      windowId: 7,
+      windowIndex: 1,
+      tabCount: 2,
+      capturedAt: "2026-03-28T12:00:00.000Z",
+      trackingStartedAt: "2026-03-28T11:55:00.000Z",
+      pollSeconds: 2,
+    },
+    tabs: [
+      {
+        path: "/Volumes/Code_2TB/code/orp",
+      },
+      {
+        title: "web",
+        path: "/Volumes/Code_2TB/code/orp-web-app",
+        resumeCommand: "claude resume claude-999",
+        resumeTool: "claude",
+        resumeSessionId: "claude-999",
+      },
+    ],
+  };
+
+  await fs.writeFile(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`, "utf8");
+  const registration = await registerWorkspaceManifest(manifestPath, manifest, { env });
+  const result = await listTrackedWorkspaces({ env });
+
+  assert.match(registration.registryPath, /workspace-registry\.json$/);
+  assert.equal(result.workspaces.length, 1);
+  assert.deepEqual(result.workspaces[0], {
+    manifestPath: path.resolve(manifestPath),
+    workspaceId: "orp-main",
+    title: "ORP Main",
+    host: "local-macbook",
+    captureMode: "watch",
+    capturedAt: "2026-03-28T12:00:00.000Z",
+    trackingStartedAt: "2026-03-28T11:55:00.000Z",
+    windowId: 7,
+    windowIndex: 1,
+    tabCount: 2,
+    codexSessionCount: 1,
+    tmuxSessionCount: 0,
+    resumeSessions: [
+      {
+        title: "web",
+        path: "/Volumes/Code_2TB/code/orp-web-app",
+        resumeCommand: "claude resume claude-999",
+        resumeTool: "claude",
+        resumeSessionId: "claude-999",
+      },
+    ],
+    registeredAt: registration.entry.registeredAt,
+    updatedAt: registration.entry.updatedAt,
+    status: "ok",
+  });
+
+  const summary = summarizeTrackedWorkspaces(result);
+  assert.match(summary, /Local tracked workspaces: 1/);
+  assert.match(summary, /ORP Main \[orp-main\]/);
+  assert.match(summary, /Saved resume sessions: 1/);
+  assert.match(summary, /web: claude resume claude-999/);
+});
+
+test("listTrackedWorkspaces retains missing manifests in the registry output", async () => {
+  const tempDir = await makeTempDir();
+  const env = {
+    ...process.env,
+    XDG_CONFIG_HOME: path.join(tempDir, "config"),
+  };
+  const manifestPath = path.join(tempDir, "workspace.json");
+  const manifest = {
+    version: "1",
+    workspaceId: "orp-main",
+    tabs: [{ path: "/Volumes/Code_2TB/code/orp" }],
+  };
+
+  await fs.writeFile(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`, "utf8");
+  await registerWorkspaceManifest(manifestPath, manifest, { env });
+  await fs.unlink(manifestPath);
+
+  const result = await listTrackedWorkspaces({ env });
+  assert.equal(result.workspaces[0]?.status, "missing");
+  assert.equal(result.workspaces[0]?.error, "manifest file not found");
+});
+
+test("summarizeTrackedWorkspaces explains how to start when nothing is registered", () => {
+  const summary = summarizeTrackedWorkspaces({
+    registryPath: "/tmp/workspace-registry.json",
+    workspaces: [],
+  });
+
+  assert.match(summary, /No local tracked workspaces yet/);
+  assert.match(summary, /orp workspace create main-cody-1/);
+  assert.match(summary, /orp workspace list/);
+});
+
+test("cacheManagedWorkspaceManifest writes a managed local cache and registers it", async () => {
+  const tempDir = await makeTempDir();
+  const env = {
+    ...process.env,
+    XDG_CONFIG_HOME: path.join(tempDir, "config"),
+  };
+
+  const result = await cacheManagedWorkspaceManifest(
+    {
+      version: "1",
+      workspaceId: "idea-123",
+      title: "Main Cody 1",
+      tabs: [{ title: "orp", path: "/Volumes/Code_2TB/code/orp" }],
+    },
+    { env },
+  );
+
+  assert.match(result.manifestPath, /workspaces\/idea-123-[a-f0-9]{8}\.json$/);
+  assert.equal(path.dirname(result.manifestPath), getManagedWorkspaceDir({ env }));
+
+  const listed = await listTrackedWorkspaces({ env });
+  assert.equal(listed.workspaces.length, 1);
+  assert.equal(listed.workspaces[0]?.workspaceId, "idea-123");
+  assert.equal(listed.workspaces[0]?.title, "Main Cody 1");
+});
+
+test("buildWorkspaceInventory merges hosted and local workspace state", () => {
+  const result = buildWorkspaceInventory({
+    localResult: {
+      registryPath: "/tmp/workspace-registry.json",
+      workspaces: [
+        {
+          manifestPath: "/Users/example/.config/orp/workspaces/idea-123-deadbeef.json",
+          workspaceId: "idea-123",
+          title: "Main Cody 1",
+          tabCount: 2,
+          codexSessionCount: 1,
+          updatedAt: "2026-03-30T12:00:00.000Z",
+          status: "ok",
+        },
+        {
+          manifestPath: "/tmp/local-only.json",
+          workspaceId: "local-only",
+          title: "Local Only",
+          tabCount: 1,
+          codexSessionCount: 0,
+          updatedAt: "2026-03-29T12:00:00.000Z",
+          status: "ok",
+        },
+      ],
+    },
+    hostedResult: {
+      source: "idea_bridge",
+      workspaces: [
+        {
+          workspace_id: "idea-123",
+          title: "Main Cody 1",
+          updatedAt: "2026-03-30T12:05:00.000Z",
+          linkedIdea: { ideaId: "ef86" },
+          metrics: { tabCount: 2 },
+          state: {
+            tabs: [
+              { project_root: "/Volumes/Code_2TB/code/orp", codex_session_id: "abc-123" },
+              { project_root: "/Volumes/Code_2TB/code/orp-web-app" },
+            ],
+          },
+          source_kind: "idea_bridge",
+        },
+      ],
+    },
+  });
+
+  assert.equal(result.workspaces.length, 2);
+  assert.equal(result.workspaces[0]?.workspaceId, "idea-123");
+  assert.equal(result.workspaces[0]?.availability, "hosted+local");
+  assert.equal(result.workspaces[0]?.syncStatus, "synced");
+  assert.equal(result.workspaces[1]?.workspaceId, "local-only");
+  assert.equal(result.workspaces[1]?.availability, "local");
+
+  const summary = summarizeWorkspaceInventory(result);
+  assert.match(summary, /Workspace inventory: 2/);
+  assert.match(summary, /Hosted available: 1/);
+  assert.match(summary, /Local available: 2/);
+  assert.match(summary, /Sync: synced/);
+});
+
+test("applyWorkspaceSlotsToInventory annotates explicit and implicit slots", async () => {
+  const tempDir = await makeTempDir();
+  const env = {
+    ...process.env,
+    XDG_CONFIG_HOME: path.join(tempDir, "config"),
+  };
+
+  await setWorkspaceSlot(
+    "offhand",
+    {
+      kind: "workspace-file",
+      workspaceId: "research-lab",
+      title: "research-lab",
+      manifestPath: "/tmp/research-lab.json",
+    },
+    { env },
+  );
+  const { slots } = await loadWorkspaceSlots({ env });
+
+  const explicitResult = applyWorkspaceSlotsToInventory(
+    buildWorkspaceInventory({
+      localResult: {
+        registryPath: "/tmp/workspace-registry.json",
+        workspaces: [
+          {
+            manifestPath: "/tmp/research-lab.json",
+            workspaceId: "research-lab",
+            title: "research-lab",
+            tabCount: 1,
+            codexSessionCount: 0,
+            updatedAt: "2026-03-30T12:00:00.000Z",
+            status: "ok",
+          },
+        ],
+      },
+      hostedResult: {
+        source: "idea_bridge",
+        workspaces: [],
+      },
+    }),
+    slots,
+  );
+
+  assert.deepEqual(explicitResult.workspaces[0]?.slots, ["offhand", "main"]);
+  assert.equal(explicitResult.workspaces[0]?.implicitMain, true);
+
+  const implicitResult = applyWorkspaceSlotsToInventory(
+    buildWorkspaceInventory({
+      localResult: {
+        registryPath: "/tmp/workspace-registry.json",
+        workspaces: [
+          {
+            manifestPath: "/tmp/main-cody-1.json",
+            workspaceId: "main-cody-1",
+            title: "main-cody-1",
+            tabCount: 2,
+            codexSessionCount: 1,
+            updatedAt: "2026-03-30T12:00:00.000Z",
+            status: "ok",
+          },
+        ],
+      },
+      hostedResult: {
+        source: "idea_bridge",
+        workspaces: [],
+      },
+    }),
+    {},
+  );
+
+  assert.deepEqual(implicitResult.workspaces[0]?.slots, ["main"]);
+  assert.equal(implicitResult.workspaces[0]?.implicitMain, true);
+  assert.match(summarizeWorkspaceInventory(implicitResult), /Slots: main \(main inferred because this is the only workspace\)/);
+});

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

@@ -0,0 +1,44 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { runOrpWorkspaceCommand } from "../src/index.js";
+
+async function captureStdout(fn) {
+  const chunks = [];
+  const originalWrite = process.stdout.write;
+  process.stdout.write = (chunk, encoding, callback) => {
+    chunks.push(typeof chunk === "string" ? chunk : chunk.toString(encoding || "utf8"));
+    if (typeof callback === "function") {
+      callback();
+    }
+    return true;
+  };
+
+  try {
+    const code = await fn();
+    return {
+      code,
+      stdout: chunks.join(""),
+    };
+  } finally {
+    process.stdout.write = originalWrite;
+  }
+}
+
+test("runOrpWorkspaceCommand shows the ledger-first help surface", async () => {
+  const { code, stdout } = await captureStdout(() => runOrpWorkspaceCommand(["-h"]));
+
+  assert.equal(code, 0);
+  assert.match(stdout, /orp workspace ledger <name-or-id>/);
+  assert.match(stdout, /orp workspace ledger add <name-or-id>/);
+  assert.match(stdout, /orp workspace ledger remove <name-or-id>/);
+  assert.match(stdout, /orp workspace tabs <name-or-id>/);
+});
+
+test("runOrpWorkspaceCommand routes ledger help to the tabs help surface", async () => {
+  const { code, stdout } = await captureStdout(() => runOrpWorkspaceCommand(["ledger", "-h"]));
+
+  assert.equal(code, 0);
+  assert.match(stdout, /ORP workspace tabs/);
+  assert.match(stdout, /copyable and includes the saved `cd \.\.\. && resume \.\.\.` recovery command/);
+});