open-research-protocol 0.4.14 → 0.4.16

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

@@ -0,0 +1,224 @@
+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 {
+  chooseImplicitMainCandidate,
+  loadWorkspaceSource,
+  resolveWorkspaceSelectorFromCollections,
+  resolveWorkspaceWatchTargets,
+} from "../src/orp.js";
+import { setWorkspaceSlot } from "../src/registry.js";
+
+async function makeTempDir() {
+  return fs.mkdtemp(path.join(os.tmpdir(), "orp-workspace-selector-"));
+}
+
+test("resolveWorkspaceSelectorFromCollections matches hosted ideas by saved workspace id and title slug", () => {
+  const ideas = [
+    {
+      id: "ef86bd4c-35b0-454c-ac90-9136a006b0af",
+      title: "Terminal paths and codex sessions 03-26-2026",
+      notes: `
+\`\`\`orp-workspace
+{
+  "version": "1",
+  "workspaceId": "workspace-main-1",
+  "title": "Main Cody 1",
+  "tabs": [
+    { "title": "orp", "path": "/Volumes/Code_2TB/code/orp" }
+  ]
+}
+\`\`\`
+`,
+    },
+  ];
+
+  const byWorkspaceId = resolveWorkspaceSelectorFromCollections("workspace-main-1", { ideas });
+  assert.equal(byWorkspaceId?.kind, "hosted-idea");
+  assert.equal(byWorkspaceId?.idea?.id, "ef86bd4c-35b0-454c-ac90-9136a006b0af");
+
+  const byTitleSlug = resolveWorkspaceSelectorFromCollections("main-cody-1", { ideas });
+  assert.equal(byTitleSlug?.title, "Main Cody 1");
+});
+
+test("resolveWorkspaceSelectorFromCollections can match local tracked workspaces by title", () => {
+  const resolved = resolveWorkspaceSelectorFromCollections("ORP Main", {
+    localWorkspaces: [
+      {
+        manifestPath: "/tmp/orp-main.json",
+        workspaceId: "orp-main",
+        title: "ORP Main",
+        status: "ok",
+      },
+    ],
+  });
+
+  assert.equal(resolved?.kind, "workspace-file");
+  assert.equal(resolved?.manifestPath, "/tmp/orp-main.json");
+});
+
+test("resolveWorkspaceSelectorFromCollections prefers hosted saved workspaces over local duplicates", () => {
+  const ideas = [
+    {
+      id: "idea-main",
+      title: "ORP Main",
+      notes: `
+\`\`\`orp-workspace
+{
+  "version": "1",
+  "workspaceId": "orp-main",
+  "title": "ORP Main",
+  "tabs": [
+    { "path": "/Volumes/Code_2TB/code/orp" }
+  ]
+}
+\`\`\`
+`,
+    },
+  ];
+  const localWorkspaces = [
+    {
+      manifestPath: "/tmp/orp-main.json",
+      workspaceId: "orp-main",
+      title: "ORP Main",
+      status: "ok",
+    },
+  ];
+
+  const resolved = resolveWorkspaceSelectorFromCollections("orp-main", {
+    ideas,
+    localWorkspaces,
+  });
+
+  assert.equal(resolved?.kind, "hosted-idea");
+  assert.equal(resolved?.idea?.id, "idea-main");
+});
+
+test("resolveWorkspaceSelectorFromCollections raises on ambiguous hosted titles", () => {
+  const ideas = [
+    {
+      id: "idea-1",
+      title: "Main Cody 1",
+      notes: `
+/Volumes/Code_2TB/code/orp
+`,
+    },
+    {
+      id: "idea-2",
+      title: "Main Cody 1",
+      notes: `
+/Volumes/Code_2TB/code/orp-web-app
+`,
+    },
+  ];
+
+  assert.throws(
+    () => resolveWorkspaceSelectorFromCollections("Main Cody 1", { ideas }),
+    /ambiguous/i,
+  );
+});
+
+test("loadWorkspaceSource resolves the main slot to an explicit local manifest", async () => {
+  const tempDir = await makeTempDir();
+  const env = {
+    ...process.env,
+    XDG_CONFIG_HOME: path.join(tempDir, "config"),
+  };
+  const manifestPath = path.join(tempDir, "main-cody-1.json");
+  await fs.writeFile(
+    manifestPath,
+    `${JSON.stringify(
+      {
+        version: "1",
+        workspaceId: "main-cody-1",
+        title: "main-cody-1",
+        tabs: [{ path: "/Volumes/Code_2TB/code/orp" }],
+      },
+      null,
+      2,
+    )}\n`,
+    "utf8",
+  );
+  await setWorkspaceSlot(
+    "main",
+    {
+      kind: "workspace-file",
+      workspaceId: "main-cody-1",
+      title: "main-cody-1",
+      manifestPath,
+    },
+    { env },
+  );
+
+  const source = await loadWorkspaceSource({
+    ideaId: "main",
+    env,
+  });
+
+  assert.equal(source.sourceType, "workspace-file");
+  assert.equal(source.sourcePath, path.resolve(manifestPath));
+  assert.equal(source.workspaceManifest?.workspaceId, "main-cody-1");
+});
+
+test("chooseImplicitMainCandidate prefers the single hosted-backed workspace over generated local captures", () => {
+  const candidate = chooseImplicitMainCandidate([
+    {
+      kind: "hosted-idea",
+      workspaceId: "idea-ef86bd4c-35b0-454c-ac90-9136a006b0af",
+      title: "Terminal paths and codex sessions 03-26-2026",
+    },
+    {
+      kind: "workspace-file",
+      workspaceId: "captured-iterm-window-20260401t032225z",
+      title: "captured-iterm-window-20260401t032225z",
+      manifestPath: "/tmp/captured-1.json",
+    },
+    {
+      kind: "workspace-file",
+      workspaceId: "captured-iterm-window-20260401t032215z",
+      title: "captured-iterm-window-20260401t032215z",
+      manifestPath: "/tmp/captured-2.json",
+    },
+  ]);
+
+  assert.equal(candidate?.kind, "hosted-idea");
+  assert.equal(candidate?.workspaceId, "idea-ef86bd4c-35b0-454c-ac90-9136a006b0af");
+});
+
+test("resolveWorkspaceWatchTargets syncs idea-bridge hosted workspaces through the linked idea", () => {
+  const targets = resolveWorkspaceWatchTargets(
+    {
+      sourceType: "hosted-workspace",
+      hostedWorkspace: {
+        workspace_id: "idea-ef86bd4c-35b0-454c-ac90-9136a006b0af",
+        source_kind: "idea_bridge",
+        linkedIdea: {
+          ideaId: "ef86bd4c-35b0-454c-ac90-9136a006b0af",
+        },
+      },
+    },
+    {},
+  );
+
+  assert.equal(targets.hostedWorkspaceId, null);
+  assert.equal(targets.syncIdeaSelector, "ef86bd4c-35b0-454c-ac90-9136a006b0af");
+});
+
+test("resolveWorkspaceWatchTargets preserves true hosted workspace ids", () => {
+  const targets = resolveWorkspaceWatchTargets(
+    {
+      sourceType: "hosted-workspace",
+      hostedWorkspace: {
+        workspace_id: "ws_orp_main",
+        source_kind: "hosted",
+      },
+    },
+    {},
+  );
+
+  assert.equal(targets.hostedWorkspaceId, "ws_orp_main");
+  assert.equal(targets.syncIdeaSelector, null);
+});

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

@@ -0,0 +1,168 @@
+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 { buildWorkspaceTabsReport, parseWorkspaceSource, parseWorkspaceTabsArgs, runWorkspaceTabs } from "../src/index.js";
+
+async function makeTempDir() {
+  return fs.mkdtemp(path.join(os.tmpdir(), "orp-workspace-tabs-"));
+}
+
+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("parseWorkspaceTabsArgs accepts JSON and workspace selectors", () => {
+  const parsed = parseWorkspaceTabsArgs([
+    "--workspace-file",
+    "/tmp/workspace.json",
+    "--json",
+  ]);
+
+  assert.equal(parsed.workspaceFile, "/tmp/workspace.json");
+  assert.equal(parsed.json, true);
+  assert.throws(() => parseWorkspaceTabsArgs(["idea-123", "idea-456"]), /unexpected argument/);
+  assert.throws(() => parseWorkspaceTabsArgs(["--wat"]), /missing value|unknown option/);
+});
+
+test("buildWorkspaceTabsReport keeps duplicate titles unique and exposes generic resume metadata", () => {
+  const parsed = parseWorkspaceSource({
+    sourceType: "hosted-idea",
+    sourceLabel: "Workspace idea",
+    title: "Workspace idea",
+    notes: `
+/Volumes/Code_2TB/code/collaboration: codex resume abc-123
+/Volumes/Code_2TB/code/anthropic-lab: claude resume claude-456
+/Volumes/Code_2TB/code/collaboration
+`,
+  });
+
+  const report = buildWorkspaceTabsReport(
+    {
+      sourceType: "hosted-idea",
+      sourceLabel: "Workspace idea",
+      title: "Workspace idea",
+    },
+    parsed,
+  );
+
+  assert.match(report.workspaceId, /^workspace-/);
+  assert.equal(report.tabCount, 3);
+  assert.equal(report.tabs[0]?.title, "collaboration");
+  assert.equal(report.tabs[0]?.resumeCommand, "codex resume abc-123");
+  assert.equal(
+    report.tabs[0]?.restartCommand,
+    "cd '/Volumes/Code_2TB/code/collaboration' && codex resume abc-123",
+  );
+  assert.equal(report.tabs[0]?.codexSessionId, "abc-123");
+  assert.equal(report.tabs[1]?.title, "anthropic-lab");
+  assert.equal(report.tabs[1]?.resumeCommand, "claude resume claude-456");
+  assert.equal(
+    report.tabs[1]?.restartCommand,
+    "cd '/Volumes/Code_2TB/code/anthropic-lab' && claude resume claude-456",
+  );
+  assert.equal(report.tabs[1]?.claudeSessionId, "claude-456");
+  assert.equal(report.tabs[2]?.title, "collaboration (2)");
+  assert.equal(report.tabs[2]?.codexSessionId, null);
+});
+
+test("runWorkspaceTabs prints JSON without launch commands", async () => {
+  const tempDir = await makeTempDir();
+  const manifestPath = path.join(tempDir, "workspace.json");
+  await fs.writeFile(
+    manifestPath,
+    `${JSON.stringify(
+      {
+        version: "1",
+        workspaceId: "orp-main",
+        title: "ORP Main",
+        tabs: [
+          {
+            title: "orp",
+            path: "/Volumes/Code_2TB/code/orp",
+            resumeCommand: "claude resume claude-999",
+            resumeTool: "claude",
+            resumeSessionId: "claude-999",
+          },
+          {
+            title: "web",
+            path: "/Volumes/Code_2TB/code/orp-web-app",
+          },
+        ],
+      },
+      null,
+      2,
+    )}\n`,
+    "utf8",
+  );
+
+  const { code, stdout } = await captureStdout(() => runWorkspaceTabs(["--workspace-file", manifestPath, "--json"]));
+  const parsed = JSON.parse(stdout);
+
+  assert.equal(code, 0);
+  assert.equal(parsed.workspaceId, "orp-main");
+  assert.equal(parsed.tabCount, 2);
+  assert.equal(parsed.tabs[0]?.title, "orp");
+  assert.equal(parsed.tabs[0]?.resumeCommand, "claude resume claude-999");
+  assert.equal(parsed.tabs[0]?.restartCommand, "cd '/Volumes/Code_2TB/code/orp' && claude resume claude-999");
+  assert.equal(parsed.tabs[0]?.claudeSessionId, "claude-999");
+  assert.equal(parsed.tabs[1]?.title, "web");
+  assert.ok(!stdout.includes('"command"'));
+});
+
+test("buildWorkspaceTabsReport canonicalizes Claude resume commands from tool and session metadata", () => {
+  const parsed = parseWorkspaceSource({
+    sourceType: "workspace-file",
+    sourceLabel: "/tmp/workspace.json",
+    title: "workspace",
+    workspaceManifest: {
+      version: "1",
+      workspaceId: "orp-main",
+      tabs: [
+        {
+          title: "anthropic-lab",
+          path: "/Volumes/Code_2TB/code/anthropic-lab",
+          resumeTool: "claude",
+          resumeSessionId: "claude-456",
+        },
+      ],
+    },
+    notes: "",
+  });
+
+  const report = buildWorkspaceTabsReport(
+    {
+      sourceType: "workspace-file",
+      sourceLabel: "/tmp/workspace.json",
+      title: "workspace",
+    },
+    parsed,
+  );
+
+  assert.equal(report.tabs[0]?.resumeCommand, "claude --resume claude-456");
+  assert.equal(
+    report.tabs[0]?.restartCommand,
+    "cd '/Volumes/Code_2TB/code/anthropic-lab' && claude --resume claude-456",
+  );
+  assert.equal(report.tabs[0]?.claudeSessionId, "claude-456");
+});

package/scripts/orp-kernel-agent-pilot.py

@@ -542,7 +542,16 @@ def _gather_metadata(model: str) -> dict[str, Any]:
     package_version = _read_json(REPO_ROOT / "package.json")["version"]
     commit = subprocess.run(["git", "rev-parse", "HEAD"], cwd=str(REPO_ROOT), capture_output=True, text=True, check=True).stdout.strip()
     branch = subprocess.run(["git", "rev-parse", "--abbrev-ref", "HEAD"], cwd=str(REPO_ROOT), capture_output=True, text=True, check=True).stdout.strip()
-    codex_version = subprocess.run(["codex", "--version"], cwd=str(REPO_ROOT), capture_output=True, text=True, check=True).stdout.strip()
+    try:
+        codex_version = subprocess.run(
+            ["codex", "--version"],
+            cwd=str(REPO_ROOT),
+            capture_output=True,
+            text=True,
+            check=True,
+        ).stdout.strip()
+    except (FileNotFoundError, subprocess.CalledProcessError):
+        codex_version = "unavailable"
     return {
         "generated_at_utc": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
         "repo_commit": commit,

package/scripts/orp-kernel-agent-replication.py

@@ -51,7 +51,16 @@ def _gather_metadata(model: str, repeats: int) -> dict[str, Any]:
     package_version = json.loads((REPO_ROOT / "package.json").read_text(encoding="utf-8"))["version"]
     commit = subprocess.run(["git", "rev-parse", "HEAD"], cwd=str(REPO_ROOT), capture_output=True, text=True, check=True).stdout.strip()
     branch = subprocess.run(["git", "rev-parse", "--abbrev-ref", "HEAD"], cwd=str(REPO_ROOT), capture_output=True, text=True, check=True).stdout.strip()
-    codex_version = subprocess.run(["codex", "--version"], cwd=str(REPO_ROOT), capture_output=True, text=True, check=True).stdout.strip()
+    try:
+        codex_version = subprocess.run(
+            ["codex", "--version"],
+            cwd=str(REPO_ROOT),
+            capture_output=True,
+            text=True,
+            check=True,
+        ).stdout.strip()
+    except (FileNotFoundError, subprocess.CalledProcessError):
+        codex_version = "unavailable"
     return {
         "generated_at_utc": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
         "repo_commit": commit,

package/scripts/orp-kernel-canonical-continuation.py

@@ -276,7 +276,16 @@ def _gather_metadata(model: str) -> dict[str, Any]:
     package_version = json.loads((REPO_ROOT / "package.json").read_text(encoding="utf-8"))["version"]
     commit = subprocess.run(["git", "rev-parse", "HEAD"], cwd=str(REPO_ROOT), capture_output=True, text=True, check=True).stdout.strip()
     branch = subprocess.run(["git", "rev-parse", "--abbrev-ref", "HEAD"], cwd=str(REPO_ROOT), capture_output=True, text=True, check=True).stdout.strip()
-    codex_version = subprocess.run(["codex", "--version"], cwd=str(REPO_ROOT), capture_output=True, text=True, check=True).stdout.strip()
+    try:
+        codex_version = subprocess.run(
+            ["codex", "--version"],
+            cwd=str(REPO_ROOT),
+            capture_output=True,
+            text=True,
+            check=True,
+        ).stdout.strip()
+    except (FileNotFoundError, subprocess.CalledProcessError):
+        codex_version = "unavailable"
     return {
         "generated_at_utc": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
         "repo_commit": commit,

package/scripts/orp-kernel-continuation-pilot.py

@@ -278,7 +278,16 @@ def _gather_metadata(model: str) -> dict[str, Any]:
     package_version = json.loads((REPO_ROOT / "package.json").read_text(encoding="utf-8"))["version"]
     commit = subprocess.run(["git", "rev-parse", "HEAD"], cwd=str(REPO_ROOT), capture_output=True, text=True, check=True).stdout.strip()
     branch = subprocess.run(["git", "rev-parse", "--abbrev-ref", "HEAD"], cwd=str(REPO_ROOT), capture_output=True, text=True, check=True).stdout.strip()
-    codex_version = subprocess.run(["codex", "--version"], cwd=str(REPO_ROOT), capture_output=True, text=True, check=True).stdout.strip()
+    try:
+        codex_version = subprocess.run(
+            ["codex", "--version"],
+            cwd=str(REPO_ROOT),
+            capture_output=True,
+            text=True,
+            check=True,
+        ).stdout.strip()
+    except (FileNotFoundError, subprocess.CalledProcessError):
+        codex_version = "unavailable"
     return {
         "generated_at_utc": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
         "repo_commit": commit,