clankerbend 0.1.1 → 0.1.3

package/launch/codex-mux-adapter.mjs

@@ -0,0 +1,175 @@
+import { createCodexDesktopCdpAdapter } from "../host/src/codex-desktop-cdp-adapter.js";
+import { PRIMARY_ACCOUNT_ID } from "./accounts.mjs";
+
+export function createCodexDesktopMuxAdapter(options = {}) {
+  return new CodexDesktopMuxAdapter(options);
+}
+
+class CodexDesktopMuxAdapter {
+  constructor(options = {}) {
+    if (!options.accountRegistry) throw new Error("accountRegistry is required");
+    this.name = "codex-desktop-mux";
+    this.cdp = true;
+    this.rendererInjection = true;
+    this.rendererFetchToLoopback = false;
+    this.accountRegistry = options.accountRegistry;
+    this.adapterOptions = options.adapterOptions || {};
+    this.providers = options.providers || undefined;
+    this.startAccountId = options.startAccountId || null;
+    this.host = null;
+    this.activeAccountId = null;
+    this.activeAdapter = null;
+    this.switching = false;
+  }
+
+  async start(host) {
+    this.host = host;
+    const account = this.startAccountId ? this.accountRegistry.get(this.startAccountId) : this.accountRegistry.getDefault();
+    await this.switchTo(account.id, { initial: true });
+  }
+
+  async stop() {
+    await this.stopActive();
+  }
+
+  async switchTo(accountId, options = {}) {
+    if (this.switching) throw new Error("Codex account switch already in progress");
+    this.switching = true;
+    try {
+      const account = this.accountRegistry.get(accountId);
+      if (!options.initial) await this.stopActive();
+      this.activeAccountId = account.id;
+      this.host.state.codexAccounts = this.accountState();
+      this.host.setDesktopStatus({
+        cdpStatus: "starting",
+        cdpPort: null,
+        desktopPid: null,
+        target: null,
+        error: null
+      });
+      this.host.updateTranscript({
+        anchors: [],
+        visibleCount: 0,
+        annotationCount: 0,
+        scroll: null,
+        updatedAt: new Date().toISOString()
+      }, { broadcast: false });
+      this.activeAdapter = createCodexDesktopCdpAdapter({
+        ...this.adapterOptions,
+        profileDir: account.electronProfile,
+        codexHome: account.codexHome,
+        resetProfileDir: false
+      });
+      await this.activeAdapter.start(this.host);
+      this.providers = this.activeAdapter.providers;
+      return {
+        switched: true,
+        activeAccountId: account.id,
+        account: this.accountRegistry.publicAccount(account)
+      };
+    } finally {
+      this.switching = false;
+      if (this.host) {
+        this.host.state.codexAccounts = this.accountState();
+        this.host.touchAndBroadcast();
+      }
+    }
+  }
+
+  async stopActive() {
+    const adapter = this.activeAdapter;
+    this.activeAdapter = null;
+    if (adapter) await adapter.stop?.();
+    if (this.host) {
+      this.host.setDesktopStatus({
+        cdpStatus: "exited",
+        cdpPort: null,
+        desktopPid: null,
+        target: null,
+        error: null
+      });
+    }
+  }
+
+  accountState() {
+    return {
+      available: true,
+      activeAccountId: this.activeAccountId,
+      maxRunningDesktopInstances: 1,
+      switching: this.switching,
+      ...this.accountRegistry.list()
+    };
+  }
+
+  async createAccount(input = {}) {
+    const account = this.accountRegistry.createManaged(input);
+    this.host.state.codexAccounts = this.accountState();
+    this.host.touchAndBroadcast();
+    return account;
+  }
+
+  async setDefault(accountId) {
+    const result = this.accountRegistry.setDefault(accountId);
+    this.host.state.codexAccounts = this.accountState();
+    this.host.touchAndBroadcast();
+    return result;
+  }
+
+  async adoptAsPrimary(accountId) {
+    await this.stopActive();
+    const result = this.accountRegistry.adoptAsPrimary(accountId);
+    const launched = await this.switchTo(PRIMARY_ACCOUNT_ID);
+    return { ...result, launched };
+  }
+
+  async rollbackPrimary(input = {}) {
+    await this.stopActive();
+    const result = this.accountRegistry.rollbackPrimary(input);
+    const launched = await this.switchTo(PRIMARY_ACCOUNT_ID);
+    return { ...result, launched };
+  }
+
+  async deleteAccount(accountId) {
+    const account = this.accountRegistry.get(accountId);
+    if (account.kind === "primary") throw new Error("primary account cannot be deleted");
+    if (accountId === this.activeAccountId) await this.stopActive();
+    const result = this.accountRegistry.deleteManaged(accountId);
+    if (accountId === this.activeAccountId) this.activeAccountId = null;
+    this.host.state.codexAccounts = this.accountState();
+    this.host.touchAndBroadcast();
+    return result;
+  }
+
+  active() {
+    if (!this.activeAdapter) throw new Error("Codex Desktop is not running");
+    return this.activeAdapter;
+  }
+
+  openPanel(...args) {
+    return this.active().openPanel(...args);
+  }
+
+  scrollToAnchor(...args) {
+    return this.active().scrollToAnchor(...args);
+  }
+
+  highlightAnchor(...args) {
+    return this.active().highlightAnchor(...args);
+  }
+
+  highlightRange(...args) {
+    return this.active().highlightRange(...args);
+  }
+
+  setComposerDraft(...args) {
+    return this.active().setComposerDraft(...args);
+  }
+
+  submitComposer(...args) {
+    return this.active().submitComposer(...args);
+  }
+
+  attachFiles(...args) {
+    return this.active().attachFiles(...args);
+  }
+}

package/launch/profiles.mjs

@@ -8,6 +8,7 @@ import {
   providersFromRendererBridges,
   readAppManifest
 } from "../host/src/app-registry.js";
+import { CodexAccountRegistry, primaryCodexHome } from "./accounts.mjs";
 import { clankerbendRuntimePaths } from "./runtime-paths.mjs";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -23,6 +24,18 @@ export const STICKY_NOTES_APP_ID = readAppManifest(STICKY_NOTES_MANIFEST_PATH).a
 export async function navigateProfile(options = {}) {
   const runtimePaths = clankerbendRuntimePaths({ stateDir: options.stateDir });
   const runDir = options.runDir || runtimePaths.runDir;
+  const registryProfileId = options.registryProfileId || process.env.ONEWILL_CLANKERBEND_PROFILE || "default";
+  const primaryElectronProfile = options.runDir ? join(runDir, "codex-profile") : runtimePaths.codexProfileDir;
+  const accountStateRoot = options.runDir && !options.stateDir ? runDir : runtimePaths.root;
+  const accountRegistry = new CodexAccountRegistry({
+    root: accountStateRoot,
+    registryPath: join(accountStateRoot, "accounts.json"),
+    accountsDir: join(accountStateRoot, "accounts"),
+    deletedDir: join(accountStateRoot, "deleted-accounts"),
+    primaryCodexHome: options.primaryCodexHome || primaryCodexHome(),
+    primaryElectronProfile
+  });
+  const codexAccount = options.accountId ? accountRegistry.get(options.accountId) : accountRegistry.getDefault();
   const profile = await loadProfileFromManifests({
     profileId: PROFILE_NAVIGATE,
     name: "Navigate",
@@ -31,12 +44,18 @@ export async function navigateProfile(options = {}) {
     hostName: "ClankerBend Navigate",
     runDir,
     runtimePaths,
+    accountRegistry,
     defaultPanelAppId: VIM_NAV_APP_ID,
     manifestPaths: configuredManifestPaths([VIM_NAV_MANIFEST_PATH, STICKY_NOTES_MANIFEST_PATH], {
       registryConfigPath: options.registryConfigPath || runtimePaths.registryConfigPath,
-      registryProfileId: options.registryProfileId
+      registryProfileId
     })
   });
+  profile.launchProfileId = registryProfileId;
+  profile.launchProfileName = profileNameFromId(registryProfileId);
+  profile.accountRegistry = accountRegistry;
+  profile.codexAccount = codexAccount;
+  profile.startAccountId = codexAccount.id;
   const bridge = codexDesktopRendererBridge();
   profile.rendererBridges = [bridge, ...profile.rendererBridges];
   profile.providers = providersFromRendererBridges(profile.rendererBridges);
@@ -81,13 +100,18 @@ function codexDesktopRendererBridge() {
 export function printLaunchStatus(profile, host, options = {}) {
   const mode = options.mockMode ? "Mock transcript" : "Codex Desktop";
   console.log("");
-  console.log(`ClankerBend: ${profile.name}`);
+  console.log(`ClankerBend profile: ${profile.launchProfileName || profile.name || "Default"}`);
   console.log(`Status: ${mode} is running`);
-  console.log(`Panel: ${host.state.panel.url}`);
   console.log(`Host: ${host.state.host.url}`);
-  if (!options.mockMode) {
-    console.log("Codex Desktop is open. Use the Browser side panel for ClankerBend apps.");
-  }
+  if (host.token) console.log(`Token: ${host.token}`);
   console.log("Press Ctrl+C to stop ClankerBend and the launched Codex Desktop process.");
   console.log("");
 }
+
+function profileNameFromId(profileId) {
+  return String(profileId || "default")
+    .split(/[-_\s]+/)
+    .filter(Boolean)
+    .map((part) => `${part.slice(0, 1).toUpperCase()}${part.slice(1)}`)
+    .join(" ") || "Default";
+}

package/launch/runtime-paths.mjs

@@ -15,6 +15,9 @@ export function clankerbendRuntimePaths(options = {}) {
     root,
     runDir: join(root, "run"),
     registryConfigPath: join(root, "registry.json"),
+    accountRegistryPath: join(root, "accounts.json"),
+    accountProfilesDir: join(root, "accounts"),
+    deletedAccountProfilesDir: join(root, "deleted-accounts"),
     appInstallDir: join(root, "apps"),
     codexProfileDir: join(root, "codex-profile")
   };

package/launch/test-accounts.mjs

@@ -0,0 +1,71 @@
+import assert from "node:assert/strict";
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { ClankerBendHost, createMockTranscriptAdapter } from "../host/src/index.js";
+import { CodexAccountRegistry, PRIMARY_ACCOUNT_ID } from "./accounts.mjs";
+
+const root = mkdtempSync(join(tmpdir(), "clankerbend-accounts-test-"));
+
+try {
+  const primaryHome = join(root, "primary-codex-home");
+  const primaryElectronProfile = join(root, "primary-electron-profile");
+  mkdirSync(primaryHome, { recursive: true });
+  mkdirSync(primaryElectronProfile, { recursive: true });
+  writeFileSync(join(primaryHome, "config.toml"), "model = \"gpt-5.4\"\n");
+  writeFileSync(join(primaryHome, "auth.json"), JSON.stringify({ auth_mode: "chatgpt", tokens: {} }));
+
+  const registry = new CodexAccountRegistry({
+    root: join(root, "state"),
+    primaryCodexHome: primaryHome,
+    primaryElectronProfile
+  });
+
+  const listed = registry.list();
+  assert.equal(listed.accounts.length, 1);
+  assert.equal(listed.accounts[0].id, PRIMARY_ACCOUNT_ID);
+  assert.equal(listed.accounts[0].codexHome, primaryHome);
+
+  const work = registry.createManaged({ id: "work", label: "Work" });
+  assert.equal(work.id, "work");
+  assert.equal(existsSync(work.codexHome), true);
+  assert.equal(existsSync(work.electronProfile), true);
+  assert.equal(readFileSync(join(work.codexHome, "config.toml"), "utf8"), "cli_auth_credentials_store = \"file\"\n");
+
+  const duplicateLabel = registry.createManaged({ label: "Work" });
+  assert.equal(duplicateLabel.id, "work-2");
+  const numericLabel = registry.createManaged({ label: "123" });
+  assert.equal(numericLabel.id, "account-123");
+
+  writeFileSync(join(work.codexHome, "auth.json"), JSON.stringify({ auth_mode: "chatgpt", tokens: { account: "work" } }));
+  const adoption = registry.adoptAsPrimary("work");
+  assert.equal(existsSync(primaryHome), true);
+  assert.equal(JSON.parse(readFileSync(join(primaryHome, "auth.json"), "utf8")).tokens.account, "work");
+  assert.equal(adoption.previousPrimary.kind, "managed");
+  assert.equal(existsSync(adoption.backup.codexHome), true);
+  assert.equal(registry.list().accounts.some((account) => account.id === "work"), false);
+
+  const rollback = registry.rollbackPrimary({ backupId: adoption.previousPrimary.id });
+  assert.equal(rollback.restoredAccountId, adoption.previousPrimary.id);
+  assert.equal(JSON.parse(readFileSync(join(primaryHome, "auth.json"), "utf8")).tokens.account, undefined);
+  assert.equal(registry.list().accounts.some((account) => account.id === rollback.replacedPrimary.id), true);
+
+  const temp = registry.createManaged({ id: "temp", label: "Temp" });
+  const deleted = registry.deleteManaged("temp");
+  assert.equal(registry.list().accounts.some((account) => account.id === "temp"), false);
+  assert.equal(existsSync(deleted.deletedRoot), true);
+  assert.equal(existsSync(deleted.codexHome), true);
+
+  const fresh = registry.createManaged({ id: "fresh", label: "Fresh" });
+  const host = new ClankerBendHost({
+    accountRegistry: registry,
+    transcriptAdapter: createMockTranscriptAdapter()
+  });
+  assert.equal(host.publicState().codexAccounts.accounts.find((account) => account.id === "fresh").auth.authJson, false);
+  writeFileSync(join(fresh.codexHome, "auth.json"), JSON.stringify({ auth_mode: "chatgpt", tokens: { account: "fresh" } }));
+  assert.equal(host.publicState().codexAccounts.accounts.find((account) => account.id === "fresh").auth.authJson, true);
+
+  console.log("clankerbend account registry tests passed");
+} finally {
+  rmSync(root, { recursive: true, force: true });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clankerbend",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "type": "module",
   "description": "OneWill ClankerBend protocol host and public reference apps.",
   "license": "MIT",

package/server.mjs

@@ -1,6 +1,6 @@
 import { pathToFileURL } from "node:url";
-import { createCodexDesktopCdpAdapter } from "./host/src/codex-desktop-cdp-adapter.js";
 import { ClankerBendHost, createMockTranscriptAdapter } from "./host/src/index.js";
+import { createCodexDesktopMuxAdapter } from "./launch/codex-mux-adapter.mjs";
 import { navigateProfile, printLaunchStatus } from "./launch/profiles.mjs";
 
 export async function launchClankerBendCodex(options = {}) {
@@ -10,7 +10,9 @@ export async function launchClankerBendCodex(options = {}) {
     stateDir: options.stateDir,
     runDir: options.runDir,
     registryConfigPath: options.registryConfigPath,
-    registryProfileId: options.registryProfileId
+    registryProfileId: options.registryProfileId,
+    accountId: options.accountId,
+    primaryCodexHome: options.primaryCodexHome
   });
 
   const host = new ClankerBendHost({
@@ -19,13 +21,18 @@ export async function launchClankerBendCodex(options = {}) {
     token: options.token || process.env.ONEWILL_CLANKERBEND_TOKEN || undefined,
     localDevInsecure,
     runDir: profile.runDir,
+    accountRegistry: profile.accountRegistry,
     transcriptAdapter: mockMode
       ? createMockTranscriptAdapter({ defaultAppId: profile.defaultPanelAppId, providers: profile.providers })
-      : createCodexDesktopCdpAdapter({
-          runDir: profile.runDir,
-          profileDir: profile.runtimePaths?.codexProfileDir,
-          rendererBridges: profile.rendererBridges,
-          providers: profile.providers
+      : createCodexDesktopMuxAdapter({
+          accountRegistry: profile.accountRegistry,
+          startAccountId: profile.startAccountId,
+          providers: profile.providers,
+          adapterOptions: {
+            runDir: profile.runDir,
+            rendererBridges: profile.rendererBridges,
+            providers: profile.providers
+          }
         })
   });