clankerbend 0.1.0 → 0.1.1

package/host/src/index.js

@@ -3,9 +3,9 @@ import http from "node:http";
 import { randomBytes } from "node:crypto";
 import { extname, join, relative, resolve } from "node:path";
 
-export const ONEWHACK_VERSION = "0.1";
+export const CLANKERBEND_VERSION = "0.1";
 
-export class OneWhackHttpError extends Error {
+export class ClankerBendHttpError extends Error {
   constructor(status, code, message, detail) {
     super(message);
     this.status = status;
@@ -15,7 +15,7 @@ export class OneWhackHttpError extends Error {
 }
 
 export function httpError(status, code, message, detail) {
-  return new OneWhackHttpError(status, code, message, detail);
+  return new ClankerBendHttpError(status, code, message, detail);
 }
 
 export function createMockTranscriptAdapter(options = {}) {
@@ -91,11 +91,11 @@ export function mockAnchor(anchorId, order, inferredRole, textPreview) {
   };
 }
 
-export class OneWhackHost {
+export class ClankerBendHost {
   constructor(options = {}) {
-    this.protocolVersion = options.protocolVersion || ONEWHACK_VERSION;
-    this.hostId = options.hostId || "onewill.onewhack.host";
-    this.hostName = options.hostName || "OneWhack Host";
+    this.protocolVersion = options.protocolVersion || CLANKERBEND_VERSION;
+    this.hostId = options.hostId || "onewill.clankerbend.host";
+    this.hostName = options.hostName || "ClankerBend Host";
     this.localDevInsecure = options.localDevInsecure === true;
     this.token = this.localDevInsecure ? "" : (isNonEmptyString(options.token) ? options.token : createSessionToken());
     this.runDir = options.runDir || null;
@@ -274,12 +274,12 @@ export class OneWhackHost {
     const app = this.apps.get(appId);
     if (!app || !this.state.host.url) return null;
     const base = `${this.state.host.url.replace(/\/$/, "")}/apps/${encodeURIComponent(app.appId)}/`;
-    return this.token ? `${base}#onewhack_token=${encodeURIComponent(this.token)}` : base;
+    return this.token ? `${base}#clankerbend_token=${encodeURIComponent(this.token)}` : base;
   }
 
   hostManifest() {
     return {
-      oneWhackVersion: this.protocolVersion,
+      clankerbendVersion: this.protocolVersion,
       hostId: this.hostId,
       hostName: this.hostName,
       capabilities: this.capabilities(),
@@ -307,7 +307,7 @@ export class OneWhackHost {
     }
     return cleanObject({
       ...loadedManifest,
-      oneWhackVersion: this.protocolVersion,
+      clankerbendVersion: this.protocolVersion,
       appId: app.appId,
       name: app.name || app.appId,
       version: app.version || loadedManifest.version,
@@ -324,7 +324,7 @@ export class OneWhackHost {
 
   publicState() {
     return {
-      protocolName: "onewhack",
+      protocolName: "clankerbend",
       protocolVersion: this.protocolVersion,
       sequence: this.state.sequence,
       generatedAt: this.state.generatedAt,
@@ -481,26 +481,26 @@ export class OneWhackHost {
       res.writeHead(204).end();
       return;
     }
-    if (url.pathname.startsWith("/onewhack/") && !this.authorized(req)) {
-      this.fail(res, 401, "unauthorized", "missing or invalid OneWhack token");
+    if (url.pathname.startsWith("/clankerbend/") && !this.authorized(req)) {
+      this.fail(res, 401, "unauthorized", "missing or invalid ClankerBend token");
       return;
     }
 
-    if (url.pathname === "/onewhack/manifest" && req.method === "GET") return this.ok(res, this.hostManifest());
-    if (url.pathname === "/onewhack/state" && req.method === "GET") return this.ok(res, this.publicState());
-    if (url.pathname === "/onewhack/events" && req.method === "GET") return this.handleEvents(req, res);
-    if (url.pathname === "/onewhack/apps" && req.method === "GET") return this.ok(res, { apps: this.appSummaries() });
-    if (url.pathname === "/onewhack/panel/open" && req.method === "POST") return this.openPanelEndpoint(req, res);
-    if (url.pathname === "/onewhack/transcript/scroll" && req.method === "POST") return this.scrollEndpoint(req, res);
-    if (url.pathname === "/onewhack/transcript/highlight" && req.method === "POST") return this.highlightEndpoint(req, res);
-    if (url.pathname === "/onewhack/transcript/highlight-range" && req.method === "POST") return this.highlightRangeEndpoint(req, res);
-    if (url.pathname === "/onewhack/selection" && req.method === "POST") return this.selectionEndpoint(req, res);
-    if (url.pathname === "/onewhack/overlay/open" && req.method === "POST") return this.overlayOpenEndpoint(req, res);
-    if (url.pathname === "/onewhack/overlay/close" && req.method === "POST") return this.overlayCloseEndpoint(req, res);
-    if (url.pathname === "/onewhack/composer/context" && req.method === "POST") return this.composerContextEndpoint(req, res);
-    if (url.pathname === "/onewhack/composer/context/remove" && req.method === "POST") return this.composerContextRemoveEndpoint(req, res);
-    if (url.pathname === "/onewhack/composer/draft" && req.method === "POST") return this.composerDraftEndpoint(req, res);
-    if (url.pathname === "/onewhack/composer/submit" && req.method === "POST") return this.composerSubmitEndpoint(req, res);
+    if (url.pathname === "/clankerbend/manifest" && req.method === "GET") return this.ok(res, this.hostManifest());
+    if (url.pathname === "/clankerbend/state" && req.method === "GET") return this.ok(res, this.publicState());
+    if (url.pathname === "/clankerbend/events" && req.method === "GET") return this.handleEvents(req, res);
+    if (url.pathname === "/clankerbend/apps" && req.method === "GET") return this.ok(res, { apps: this.appSummaries() });
+    if (url.pathname === "/clankerbend/panel/open" && req.method === "POST") return this.openPanelEndpoint(req, res);
+    if (url.pathname === "/clankerbend/transcript/scroll" && req.method === "POST") return this.scrollEndpoint(req, res);
+    if (url.pathname === "/clankerbend/transcript/highlight" && req.method === "POST") return this.highlightEndpoint(req, res);
+    if (url.pathname === "/clankerbend/transcript/highlight-range" && req.method === "POST") return this.highlightRangeEndpoint(req, res);
+    if (url.pathname === "/clankerbend/selection" && req.method === "POST") return this.selectionEndpoint(req, res);
+    if (url.pathname === "/clankerbend/overlay/open" && req.method === "POST") return this.overlayOpenEndpoint(req, res);
+    if (url.pathname === "/clankerbend/overlay/close" && req.method === "POST") return this.overlayCloseEndpoint(req, res);
+    if (url.pathname === "/clankerbend/composer/context" && req.method === "POST") return this.composerContextEndpoint(req, res);
+    if (url.pathname === "/clankerbend/composer/context/remove" && req.method === "POST") return this.composerContextRemoveEndpoint(req, res);
+    if (url.pathname === "/clankerbend/composer/draft" && req.method === "POST") return this.composerDraftEndpoint(req, res);
+    if (url.pathname === "/clankerbend/composer/submit" && req.method === "POST") return this.composerSubmitEndpoint(req, res);
 
     const appRoute = this.parseAppRoute(url.pathname);
     if (appRoute && req.method === "GET" && appRoute.tail === "/manifest") return this.ok(res, this.appManifest(appRoute.appId));
@@ -524,7 +524,7 @@ export class OneWhackHost {
   }
 
   parseAppRoute(pathname) {
-    if (!pathname.startsWith("/onewhack/apps/")) return null;
+    if (!pathname.startsWith("/clankerbend/apps/")) return null;
     const parts = pathname.split("/");
     const appId = decodeURIComponent(parts[3] || "");
     if (!appId) return null;
@@ -594,7 +594,7 @@ export class OneWhackHost {
         this.state.panel.error = null;
       } else {
         this.state.panel.status = "waiting";
-        this.state.panel.error = result?.error || "Open a Codex thread, then try opening the OneWhack panel again.";
+        this.state.panel.error = result?.error || "Open a Codex thread, then try opening the ClankerBend panel again.";
       }
       this.touchAndBroadcast();
       return this.ok(res, result || { ok: false, error: "panel unavailable" });

package/launch/profiles.mjs

@@ -8,33 +8,33 @@ import {
   providersFromRendererBridges,
   readAppManifest
 } from "../host/src/app-registry.js";
-import { oneWhackRuntimePaths } from "./runtime-paths.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 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,
     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: options.registryProfileId
     })
   });
   const bridge = codexDesktopRendererBridge();
@@ -44,9 +44,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 +81,13 @@ 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.name}`);
   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("Codex Desktop is open. Use the Browser side panel for ClankerBend apps.");
   }
-  console.log("Press Ctrl+C to stop OneWhack and the launched Codex Desktop process.");
+  console.log("Press Ctrl+C to stop ClankerBend and the launched Codex Desktop process.");
   console.log("");
 }

package/launch/runtime-paths.mjs

@@ -1,16 +1,16 @@
 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"),

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "clankerbend",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "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,11 +1,11 @@
 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 { 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,
@@ -13,10 +13,10 @@ export async function launchOneWhackCodex(options = {}) {
     registryProfileId: options.registryProfileId
   });
 
-  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,
     transcriptAdapter: mockMode
@@ -41,7 +41,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 +52,7 @@ export async function launchOneWhackCodex(options = {}) {
 }
 
 if (import.meta.url === pathToFileURL(process.argv[1] || "").href) {
-  await launchOneWhackCodex({
+  await launchClankerBendCodex({
     mock: process.argv.includes("--mock")
   });
 }