clankerbend 0.1.0 → 0.1.2

package/launch/accounts.mjs

@@ -0,0 +1,360 @@
+import { cpSync, existsSync, mkdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+
+export const ACCOUNT_REGISTRY_VERSION = 1;
+export const PRIMARY_ACCOUNT_ID = "primary";
+export const MAX_ACCOUNT_PROFILES = 20;
+
+export function primaryCodexHome() {
+  return process.env.CODEX_HOME ? resolve(process.env.CODEX_HOME) : join(homedir(), ".codex");
+}
+
+export class CodexAccountRegistry {
+  constructor(options = {}) {
+    if (!options.root) throw new Error("account registry root is required");
+    if (!options.primaryElectronProfile) throw new Error("primary electron profile is required");
+    this.root = resolve(options.root);
+    this.registryPath = options.registryPath || join(this.root, "accounts.json");
+    this.accountsDir = options.accountsDir || join(this.root, "accounts");
+    this.deletedDir = options.deletedDir || join(this.root, "deleted-accounts");
+    this.primaryCodexHome = resolve(options.primaryCodexHome || primaryCodexHome());
+    this.primaryElectronProfile = resolve(options.primaryElectronProfile);
+    this.maxAccounts = options.maxAccounts || MAX_ACCOUNT_PROFILES;
+    this.registry = this.load();
+  }
+
+  list() {
+    this.ensurePrimary();
+    return {
+      version: ACCOUNT_REGISTRY_VERSION,
+      clankerbendDefaultAccountId: this.registry.clankerbendDefaultAccountId || PRIMARY_ACCOUNT_ID,
+      maxAccounts: this.maxAccounts,
+      accounts: this.registry.accounts.map((account) => this.publicAccount(account)),
+      backups: this.registry.backups || [],
+      deletedAccounts: this.registry.deletedAccounts || []
+    };
+  }
+
+  get(id) {
+    this.ensurePrimary();
+    const account = this.registry.accounts.find((candidate) => candidate.id === id);
+    if (!account) throw new Error(`unknown Codex account profile: ${id}`);
+    return account;
+  }
+
+  getDefault() {
+    const id = this.registry.clankerbendDefaultAccountId || PRIMARY_ACCOUNT_ID;
+    return this.registry.accounts.find((account) => account.id === id) || this.get(PRIMARY_ACCOUNT_ID);
+  }
+
+  createManaged(input = {}) {
+    this.ensurePrimary();
+    if (this.registry.accounts.length >= this.maxAccounts) {
+      throw new Error(`Codex account profile limit reached (${this.maxAccounts})`);
+    }
+    const id = input.id
+      ? safeAccountId(input.id)
+      : uniqueAccountId(this.registry.accounts, accountIdFromLabel(input.label || "account"));
+    if (input.id && this.registry.accounts.some((account) => account.id === id)) {
+      throw new Error(`Codex account profile already exists: ${id}`);
+    }
+    const accountRoot = join(this.accountsDir, id);
+    const codexHome = join(accountRoot, "codex-home");
+    const electronProfile = join(accountRoot, "electron-profile");
+    mkdirSync(codexHome, { recursive: true, mode: 0o700 });
+    mkdirSync(electronProfile, { recursive: true, mode: 0o700 });
+    writeManagedConfig(codexHome, this.primaryCodexHome);
+    const account = {
+      id,
+      kind: "managed",
+      label: String(input.label || id),
+      codexHome,
+      electronProfile,
+      createdAt: new Date().toISOString(),
+      createdFrom: PRIMARY_ACCOUNT_ID
+    };
+    this.registry.accounts.push(account);
+    this.save();
+    return this.publicAccount(account);
+  }
+
+  setDefault(id) {
+    this.get(id);
+    this.registry.clankerbendDefaultAccountId = id;
+    this.save();
+    return this.list();
+  }
+
+  adoptAsPrimary(id) {
+    const target = this.get(id);
+    if (target.kind === "primary") throw new Error("primary account is already the primary Codex home");
+    const timestamp = timestampSegment();
+    const primary = this.get(PRIMARY_ACCOUNT_ID);
+    const oldPrimaryId = uniqueAccountId(this.registry.accounts, `previous-primary-${timestamp}`);
+    const backupCodexHome = `${this.primaryCodexHome}.backup_${timestamp}`;
+    const oldPrimaryElectronProfile = join(this.accountsDir, oldPrimaryId, "electron-profile");
+    const rollbackBackup = {
+      id: oldPrimaryId,
+      label: `Previous Primary ${timestamp}`,
+      codexHome: backupCodexHome,
+      createdAt: new Date().toISOString(),
+      reason: "adopt-as-primary"
+    };
+
+    if (!existsSync(target.codexHome)) throw new Error(`target CODEX_HOME does not exist: ${target.codexHome}`);
+    if (existsSync(backupCodexHome)) throw new Error(`backup path already exists: ${backupCodexHome}`);
+
+    if (existsSync(this.primaryCodexHome)) movePath(this.primaryCodexHome, backupCodexHome);
+    if (existsSync(primary.electronProfile)) movePath(primary.electronProfile, oldPrimaryElectronProfile);
+    movePath(target.codexHome, this.primaryCodexHome);
+    if (existsSync(target.electronProfile)) movePath(target.electronProfile, primary.electronProfile);
+    else mkdirSync(primary.electronProfile, { recursive: true, mode: 0o700 });
+
+    const oldPrimary = {
+      id: oldPrimaryId,
+      kind: "managed",
+      label: rollbackBackup.label,
+      codexHome: backupCodexHome,
+      electronProfile: oldPrimaryElectronProfile,
+      createdAt: rollbackBackup.createdAt,
+      createdFrom: PRIMARY_ACCOUNT_ID,
+      backup: true
+    };
+    primary.lastAdoptedFrom = target.id;
+    primary.lastAdoptedAt = new Date().toISOString();
+    primary.codexHome = this.primaryCodexHome;
+    primary.electronProfile = this.primaryElectronProfile;
+    this.registry.accounts = this.registry.accounts
+      .filter((account) => account.id !== target.id)
+      .map((account) => account.id === PRIMARY_ACCOUNT_ID ? primary : account);
+    this.registry.accounts.push(oldPrimary);
+    this.registry.backups = [...(this.registry.backups || []), rollbackBackup];
+    this.registry.clankerbendDefaultAccountId = PRIMARY_ACCOUNT_ID;
+    this.save();
+    return {
+      adoptedAccountId: id,
+      primary: this.publicAccount(primary),
+      previousPrimary: this.publicAccount(oldPrimary),
+      backup: rollbackBackup
+    };
+  }
+
+  rollbackPrimary(input = {}) {
+    const backupId = input.backupId || input.accountId;
+    if (!backupId) throw new Error("backupId is required");
+    const backupAccount = this.get(backupId);
+    if (backupAccount.kind === "primary") throw new Error("cannot rollback from primary account");
+    if (!existsSync(backupAccount.codexHome)) throw new Error(`backup CODEX_HOME does not exist: ${backupAccount.codexHome}`);
+
+    const timestamp = timestampSegment();
+    const primary = this.get(PRIMARY_ACCOUNT_ID);
+    const replacedId = uniqueAccountId(this.registry.accounts, `rollback-replaced-${timestamp}`);
+    const replacedCodexHome = `${this.primaryCodexHome}.rollback_replaced_${timestamp}`;
+    const replacedElectronProfile = join(this.accountsDir, replacedId, "electron-profile");
+
+    if (existsSync(this.primaryCodexHome)) movePath(this.primaryCodexHome, replacedCodexHome);
+    if (existsSync(primary.electronProfile)) movePath(primary.electronProfile, replacedElectronProfile);
+    movePath(backupAccount.codexHome, this.primaryCodexHome);
+    if (existsSync(backupAccount.electronProfile)) movePath(backupAccount.electronProfile, primary.electronProfile);
+    else mkdirSync(primary.electronProfile, { recursive: true, mode: 0o700 });
+
+    const replacedAccount = {
+      id: replacedId,
+      kind: "managed",
+      label: `Rollback Replaced ${timestamp}`,
+      codexHome: replacedCodexHome,
+      electronProfile: replacedElectronProfile,
+      createdAt: new Date().toISOString(),
+      createdFrom: PRIMARY_ACCOUNT_ID,
+      backup: true
+    };
+    primary.lastRollbackFrom = backupAccount.id;
+    primary.lastRollbackAt = new Date().toISOString();
+    primary.codexHome = this.primaryCodexHome;
+    primary.electronProfile = this.primaryElectronProfile;
+    this.registry.accounts = this.registry.accounts
+      .filter((account) => account.id !== backupAccount.id)
+      .map((account) => account.id === PRIMARY_ACCOUNT_ID ? primary : account);
+    this.registry.accounts.push(replacedAccount);
+    this.registry.backups = [...(this.registry.backups || []), {
+      id: replacedId,
+      label: replacedAccount.label,
+      codexHome: replacedCodexHome,
+      createdAt: replacedAccount.createdAt,
+      reason: "rollback-replaced-primary"
+    }];
+    this.registry.clankerbendDefaultAccountId = PRIMARY_ACCOUNT_ID;
+    this.save();
+    return {
+      restoredAccountId: backupAccount.id,
+      primary: this.publicAccount(primary),
+      replacedPrimary: this.publicAccount(replacedAccount)
+    };
+  }
+
+  deleteManaged(id) {
+    const account = this.get(id);
+    if (account.kind === "primary") throw new Error("primary account cannot be deleted");
+    const timestamp = timestampSegment();
+    const deleteRoot = join(this.deletedDir, `${id}_${timestamp}`);
+    mkdirSync(deleteRoot, { recursive: true, mode: 0o700 });
+    const deleted = {
+      id,
+      label: account.label,
+      deletedAt: new Date().toISOString(),
+      originalCodexHome: account.codexHome,
+      originalElectronProfile: account.electronProfile,
+      deletedRoot: deleteRoot,
+      codexHome: null,
+      electronProfile: null
+    };
+    if (existsSync(account.codexHome)) {
+      const destination = join(deleteRoot, "codex-home");
+      movePath(account.codexHome, destination);
+      deleted.codexHome = destination;
+    }
+    if (existsSync(account.electronProfile)) {
+      const destination = join(deleteRoot, "electron-profile");
+      movePath(account.electronProfile, destination);
+      deleted.electronProfile = destination;
+    }
+    this.registry.accounts = this.registry.accounts.filter((candidate) => candidate.id !== id);
+    if (this.registry.clankerbendDefaultAccountId === id) this.registry.clankerbendDefaultAccountId = PRIMARY_ACCOUNT_ID;
+    this.registry.deletedAccounts = [...(this.registry.deletedAccounts || []), deleted];
+    this.save();
+    return deleted;
+  }
+
+  load() {
+    mkdirSync(this.root, { recursive: true, mode: 0o700 });
+    mkdirSync(this.accountsDir, { recursive: true, mode: 0o700 });
+    let registry = null;
+    if (existsSync(this.registryPath)) {
+      registry = JSON.parse(readFileSync(this.registryPath, "utf8"));
+    }
+    registry ||= {
+      version: ACCOUNT_REGISTRY_VERSION,
+      clankerbendDefaultAccountId: PRIMARY_ACCOUNT_ID,
+      accounts: [],
+      backups: [],
+      deletedAccounts: []
+    };
+    registry.version = ACCOUNT_REGISTRY_VERSION;
+    registry.accounts = Array.isArray(registry.accounts) ? registry.accounts : [];
+    registry.backups = Array.isArray(registry.backups) ? registry.backups : [];
+    registry.deletedAccounts = Array.isArray(registry.deletedAccounts) ? registry.deletedAccounts : [];
+    this.registry = registry;
+    this.ensurePrimary();
+    return this.registry;
+  }
+
+  ensurePrimary() {
+    const primary = this.registry.accounts.find((account) => account.id === PRIMARY_ACCOUNT_ID);
+    if (primary) {
+      primary.kind = "primary";
+      primary.label ||= "Primary";
+      primary.codexHome = this.primaryCodexHome;
+      primary.electronProfile = this.primaryElectronProfile;
+      return primary;
+    }
+    const account = {
+      id: PRIMARY_ACCOUNT_ID,
+      kind: "primary",
+      label: "Primary",
+      codexHome: this.primaryCodexHome,
+      electronProfile: this.primaryElectronProfile,
+      createdAt: new Date().toISOString()
+    };
+    this.registry.accounts.unshift(account);
+    this.registry.clankerbendDefaultAccountId ||= PRIMARY_ACCOUNT_ID;
+    this.save();
+    return account;
+  }
+
+  save() {
+    mkdirSync(dirname(this.registryPath), { recursive: true, mode: 0o700 });
+    writeFileSync(this.registryPath, `${JSON.stringify(this.registry, null, 2)}\n`, { mode: 0o600 });
+  }
+
+  publicAccount(account) {
+    return {
+      id: account.id,
+      kind: account.kind,
+      label: account.label,
+      codexHome: account.codexHome,
+      electronProfile: account.electronProfile,
+      auth: {
+        authJson: existsSync(join(account.codexHome, "auth.json")),
+        configToml: existsSync(join(account.codexHome, "config.toml"))
+      },
+      createdAt: account.createdAt,
+      createdFrom: account.createdFrom,
+      backup: account.backup || undefined,
+      lastSeenAccount: account.lastSeenAccount || undefined,
+      lastAdoptedFrom: account.lastAdoptedFrom || undefined,
+      lastAdoptedAt: account.lastAdoptedAt || undefined,
+      lastRollbackFrom: account.lastRollbackFrom || undefined,
+      lastRollbackAt: account.lastRollbackAt || undefined
+    };
+  }
+}
+
+function writeManagedConfig(codexHome, primaryHome) {
+  const primaryConfig = join(primaryHome, "config.toml");
+  let content = "";
+  if (existsSync(primaryConfig)) {
+    const match = readFileSync(primaryConfig, "utf8").match(/^\s*cli_auth_credentials_store\s*=.*$/m);
+    if (match) content = `${match[0].trim()}\n`;
+  }
+  if (!content && existsSync(join(primaryHome, "auth.json"))) {
+    content = "cli_auth_credentials_store = \"file\"\n";
+  }
+  if (content) writeFileSync(join(codexHome, "config.toml"), content, { mode: 0o600 });
+}
+
+function accountIdFromLabel(label) {
+  const id = String(label || "account")
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9_-]+/g, "-")
+    .replace(/^-+|-+$/g, "")
+    .slice(0, 40);
+  if (!id) return "account";
+  return /^[a-z]/.test(id) ? id : `account-${id}`.slice(0, 40);
+}
+
+function safeAccountId(id) {
+  const value = String(id || "").trim();
+  if (!/^[a-z][a-z0-9_-]{0,39}$/.test(value)) {
+    throw new Error("account id must start with a lowercase letter and contain only lowercase letters, numbers, _ or -");
+  }
+  return value;
+}
+
+function uniqueAccountId(accounts, base) {
+  let candidate = safeAccountId(base);
+  let suffix = 2;
+  while (accounts.some((account) => account.id === candidate)) {
+    candidate = safeAccountId(`${base}-${suffix}`);
+    suffix += 1;
+  }
+  return candidate;
+}
+
+function timestampSegment(date = new Date()) {
+  return date.toISOString().replace(/\..*$/, "").replace("T", "_").replace(/:/g, "");
+}
+
+function movePath(from, to) {
+  mkdirSync(dirname(to), { recursive: true, mode: 0o700 });
+  try {
+    renameSync(from, to);
+  } catch (err) {
+    if (err?.code !== "EXDEV") throw err;
+    const stat = statSync(from);
+    if (stat.isDirectory()) cpSync(from, to, { recursive: true, force: false });
+    else cpSync(from, to, { force: false });
+    rmSync(from, { recursive: true, force: true });
+  }
+}

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,35 +8,54 @@ import {
   providersFromRendererBridges,
   readAppManifest
 } from "../host/src/app-registry.js";
-import { oneWhackRuntimePaths } from "./runtime-paths.mjs";
+import { CodexAccountRegistry, primaryCodexHome } from "./accounts.mjs";
+import { clankerbendRuntimePaths } from "./runtime-paths.mjs";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const ROOT_DIR = join(__dirname, "..");
 
 export const PROFILE_NAVIGATE = "navigate";
-export const VIM_NAV_MANIFEST_PATH = join(ROOT_DIR, "apps/vim-nav/onewhack.manifest.json");
-export const STICKY_NOTES_MANIFEST_PATH = join(ROOT_DIR, "apps/sticky-notes/onewhack.manifest.json");
+export const VIM_NAV_MANIFEST_PATH = join(ROOT_DIR, "apps/vim-nav/clankerbend.manifest.json");
+export const STICKY_NOTES_MANIFEST_PATH = join(ROOT_DIR, "apps/sticky-notes/clankerbend.manifest.json");
 export const CODEX_DESKTOP_RENDERER_BRIDGE_PATH = join(ROOT_DIR, "host/src/codex-desktop-renderer-bridge.js");
 export const VIM_NAV_APP_ID = readAppManifest(VIM_NAV_MANIFEST_PATH).appId;
 export const STICKY_NOTES_APP_ID = readAppManifest(STICKY_NOTES_MANIFEST_PATH).appId;
 
 export async function navigateProfile(options = {}) {
-  const runtimePaths = oneWhackRuntimePaths({ stateDir: options.stateDir });
+  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",
     description: "Codex Desktop with OneWill Navigate transcript controls.",
-    hostId: "onewill.onewhack.host",
-    hostName: "OneWhack Navigate",
+    hostId: "onewill.clankerbend.host",
+    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 || "public"
+      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);
@@ -44,9 +63,9 @@ export async function navigateProfile(options = {}) {
 }
 
 export function configuredManifestPaths(baseManifestPaths, options = {}) {
-  const runtimePaths = oneWhackRuntimePaths({ stateDir: options.stateDir });
-  const configPath = options.registryConfigPath || process.env.ONEWILL_ONEWHACK_REGISTRY_CONFIG || runtimePaths.registryConfigPath;
-  const profileId = options.registryProfileId || process.env.ONEWILL_ONEWHACK_PROFILE || "default";
+  const runtimePaths = clankerbendRuntimePaths({ stateDir: options.stateDir });
+  const configPath = options.registryConfigPath || process.env.ONEWILL_CLANKERBEND_REGISTRY_CONFIG || runtimePaths.registryConfigPath;
+  const profileId = options.registryProfileId || process.env.ONEWILL_CLANKERBEND_PROFILE || "default";
   const config = loadRegistryConfig(configPath);
   return mergeManifestPaths(baseManifestPaths, enabledManifestPathsFromConfig(config, profileId));
 }
@@ -81,13 +100,18 @@ function codexDesktopRendererBridge() {
 export function printLaunchStatus(profile, host, options = {}) {
   const mode = options.mockMode ? "Mock transcript" : "Codex Desktop";
   console.log("");
-  console.log(`OneWhack: ${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 OneWhack apps.");
-  }
-  console.log("Press Ctrl+C to stop OneWhack and the launched Codex Desktop process.");
+  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

@@ -1,20 +1,23 @@
 import { homedir, platform } from "node:os";
 import { join } from "node:path";
 
-export function oneWhackStateDir() {
-  if (process.env.ONEWILL_ONEWHACK_STATE_DIR) return process.env.ONEWILL_ONEWHACK_STATE_DIR;
+export function clankerbendStateDir() {
+  if (process.env.ONEWILL_CLANKERBEND_STATE_DIR) return process.env.ONEWILL_CLANKERBEND_STATE_DIR;
   if (platform() === "darwin") {
-    return join(homedir(), "Library/Application Support/OneWill/OneWhack");
+    return join(homedir(), "Library/Application Support/OneWill/ClankerBend");
   }
-  return join(homedir(), ".local/state/onewill/onewhack");
+  return join(homedir(), ".local/state/onewill/clankerbend");
 }
 
-export function oneWhackRuntimePaths(options = {}) {
-  const root = options.stateDir || oneWhackStateDir();
+export function clankerbendRuntimePaths(options = {}) {
+  const root = options.stateDir || clankerbendStateDir();
   return {
     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")
   };