clankerbend 0.1.0 → 0.1.2

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,8 +1,8 @@
 {
   "name": "clankerbend",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "type": "module",
-  "description": "OneWill Extension Hacks protocol host and public reference apps.",
+  "description": "OneWill ClankerBend protocol host and public reference apps.",
   "license": "MIT",
   "keywords": [
     "codex",
@@ -10,13 +10,13 @@
     "desktop",
     "extensions"
   ],
-  "homepage": "https://github.com/OneWillAI/OneWhack#readme",
+  "homepage": "https://github.com/OneWillAI/clankerbend#readme",
   "bugs": {
-    "url": "https://github.com/OneWillAI/OneWhack/issues"
+    "url": "https://github.com/OneWillAI/clankerbend/issues"
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/OneWillAI/OneWhack.git"
+    "url": "git+https://github.com/OneWillAI/clankerbend.git"
   },
   "bin": {
     "clankerbend": "./cli.mjs"
@@ -24,17 +24,19 @@
   "files": [
     "cli.mjs",
     "server.mjs",
-    "assets/onewhack.jpg",
+    "assets/clankerbend-banner.webp",
+    "assets/clankerbend-demo-thumbnail.webp",
+    "assets/clankerbend.svg",
     "scripts/release-npm.mjs",
     "host/src",
     "launch",
     "apps/README.md",
-    "apps/vim-nav/onewhack.manifest.json",
+    "apps/vim-nav/clankerbend.manifest.json",
     "apps/vim-nav/package.json",
     "apps/vim-nav/public",
     "apps/vim-nav/src",
     "apps/vim-nav/README.md",
-    "apps/sticky-notes/onewhack.manifest.json",
+    "apps/sticky-notes/clankerbend.manifest.json",
     "apps/sticky-notes/package.json",
     "apps/sticky-notes/public",
     "apps/sticky-notes/src",
@@ -49,8 +51,8 @@
     "apps/*"
   ],
   "scripts": {
-    "start": "node cli.mjs codex",
-    "start:mock": "node cli.mjs codex --mock",
+    "start": "node cli.mjs",
+    "start:mock": "node cli.mjs --mock",
     "test": "node scripts/test.mjs",
     "test:vim-nav": "npm --prefix apps/vim-nav test",
     "test:sticky-notes": "npm --prefix apps/sticky-notes test",

package/scripts/release-npm.mjs

@@ -95,7 +95,7 @@ function isKnownProvenanceCi() {
 }
 
 async function repackWithName(tarball, packageName) {
-  const stageRoot = await mkdtemp(join(tmpdir(), "onewhack-npm-release-"));
+  const stageRoot = await mkdtemp(join(tmpdir(), "clankerbend-npm-release-"));
   try {
     await execFileAsync("tar", ["-xzf", tarball, "-C", stageRoot], { cwd: ROOT });
     const packageDir = join(stageRoot, "package");
@@ -195,7 +195,6 @@ function splitCompoundName(part) {
   const tokens = [part];
   if (part.includes("clanker")) tokens.push("clanker");
   if (part.includes("bend")) tokens.push("bend");
-  if (part.includes("whack")) tokens.push("whack");
   if (part.includes("onewill")) tokens.push("onewill");
   if (part.includes("ai")) tokens.push("ai");
   return tokens;

package/server.mjs

@@ -1,31 +1,38 @@
 import { pathToFileURL } from "node:url";
-import { createCodexDesktopCdpAdapter } from "./host/src/codex-desktop-cdp-adapter.js";
-import { OneWhackHost, createMockTranscriptAdapter } from "./host/src/index.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 launchOneWhackCodex(options = {}) {
+export async function launchClankerBendCodex(options = {}) {
   const mockMode = Boolean(options.mock);
-  const localDevInsecure = options.localDevInsecure === true || process.env.ONEWILL_ONEWHACK_DISABLE_AUTH === "1";
+  const localDevInsecure = options.localDevInsecure === true || process.env.ONEWILL_CLANKERBEND_DISABLE_AUTH === "1";
   const profile = await navigateProfile({
     stateDir: options.stateDir,
     runDir: options.runDir,
     registryConfigPath: options.registryConfigPath,
-    registryProfileId: options.registryProfileId
+    registryProfileId: options.registryProfileId,
+    accountId: options.accountId,
+    primaryCodexHome: options.primaryCodexHome
   });
 
-  const host = new OneWhackHost({
+  const host = new ClankerBendHost({
     hostId: profile.hostId,
     hostName: profile.hostName,
-    token: options.token || process.env.ONEWILL_ONEWHACK_TOKEN || undefined,
+    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
+          }
         })
   });
 
@@ -41,7 +48,7 @@ export async function launchOneWhackCodex(options = {}) {
     process.once("SIGINT", () => cleanupAndExit(0));
     process.once("SIGTERM", () => cleanupAndExit(0));
     process.once("uncaughtException", (err) => {
-      console.error(`OneWhack could not start. Close any OneWhack-launched Codex Desktop window, then run this command again. Details: ${err.message}`);
+      console.error(`ClankerBend could not start. Close any ClankerBend-launched Codex Desktop window, then run this command again. Details: ${err.message}`);
       cleanupAndExit(1);
     });
   }
@@ -52,7 +59,7 @@ export async function launchOneWhackCodex(options = {}) {
 }
 
 if (import.meta.url === pathToFileURL(process.argv[1] || "").href) {
-  await launchOneWhackCodex({
+  await launchClankerBendCodex({
     mock: process.argv.includes("--mock")
   });
 }