clankerbend 0.1.0

package/launch/profiles.mjs

@@ -0,0 +1,93 @@
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import {
+  enabledManifestPathsFromConfig,
+  loadProfileFromManifests,
+  loadRegistryConfig,
+  mergeManifestPaths,
+  providersFromRendererBridges,
+  readAppManifest
+} from "../host/src/app-registry.js";
+import { oneWhackRuntimePaths } 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 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 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",
+    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"
+    })
+  });
+  const bridge = codexDesktopRendererBridge();
+  profile.rendererBridges = [bridge, ...profile.rendererBridges];
+  profile.providers = providersFromRendererBridges(profile.rendererBridges);
+  return profile;
+}
+
+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 config = loadRegistryConfig(configPath);
+  return mergeManifestPaths(baseManifestPaths, enabledManifestPathsFromConfig(config, profileId));
+}
+
+export function navigateProviders() {
+  return providersFromRendererBridges([codexDesktopRendererBridge(), {
+    appId: STICKY_NOTES_APP_ID,
+    provides: [
+      "composerContext",
+      "composerDraft"
+    ]
+  }]);
+}
+
+function codexDesktopRendererBridge() {
+  return {
+    appId: VIM_NAV_APP_ID,
+    injectedScriptPath: CODEX_DESKTOP_RENDERER_BRIDGE_PATH,
+    openPanelMethod: "openPanel",
+    scrollMethod: "scrollToAnchor",
+    highlightMethod: "highlightAnchor",
+    primary: true,
+    provides: [
+      "transcriptSnapshot",
+      "transcriptOrder",
+      "transcriptNavigation",
+      "transcriptHighlight"
+    ]
+  };
+}
+
+export function printLaunchStatus(profile, host, options = {}) {
+  const mode = options.mockMode ? "Mock transcript" : "Codex Desktop";
+  console.log("");
+  console.log(`OneWhack: ${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("Press Ctrl+C to stop OneWhack and the launched Codex Desktop process.");
+  console.log("");
+}

package/launch/runtime-paths.mjs

@@ -0,0 +1,21 @@
+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;
+  if (platform() === "darwin") {
+    return join(homedir(), "Library/Application Support/OneWill/OneWhack");
+  }
+  return join(homedir(), ".local/state/onewill/onewhack");
+}
+
+export function oneWhackRuntimePaths(options = {}) {
+  const root = options.stateDir || oneWhackStateDir();
+  return {
+    root,
+    runDir: join(root, "run"),
+    registryConfigPath: join(root, "registry.json"),
+    appInstallDir: join(root, "apps"),
+    codexProfileDir: join(root, "codex-profile")
+  };
+}

package/package.json

@@ -0,0 +1,66 @@
+{
+  "name": "clankerbend",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "OneWill Extension Hacks protocol host and public reference apps.",
+  "license": "MIT",
+  "keywords": [
+    "codex",
+    "clankerbend",
+    "desktop",
+    "extensions"
+  ],
+  "homepage": "https://github.com/OneWillAI/OneWhack#readme",
+  "bugs": {
+    "url": "https://github.com/OneWillAI/OneWhack/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/OneWillAI/OneWhack.git"
+  },
+  "bin": {
+    "clankerbend": "./cli.mjs"
+  },
+  "files": [
+    "cli.mjs",
+    "server.mjs",
+    "assets/onewhack.jpg",
+    "scripts/release-npm.mjs",
+    "host/src",
+    "launch",
+    "apps/README.md",
+    "apps/vim-nav/onewhack.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/package.json",
+    "apps/sticky-notes/public",
+    "apps/sticky-notes/src",
+    "apps/sticky-notes/README.md",
+    "docs",
+    "DEVELOPERS.md",
+    "README.md",
+    "LICENSE"
+  ],
+  "workspaces": [
+    "host",
+    "apps/*"
+  ],
+  "scripts": {
+    "start": "node cli.mjs codex",
+    "start:mock": "node cli.mjs codex --mock",
+    "test": "node scripts/test.mjs",
+    "test:vim-nav": "npm --prefix apps/vim-nav test",
+    "test:sticky-notes": "npm --prefix apps/sticky-notes test",
+    "test:vim-nav:desktop-real": "npm --prefix apps/vim-nav run test:desktop-real",
+    "test:sticky-notes:desktop-real": "npm --prefix apps/sticky-notes run test:desktop-real",
+    "test:desktop-real:integration": "npm run test:vim-nav:desktop-real && npm run test:sticky-notes:desktop-real",
+    "release:pack": "node scripts/release-npm.mjs pack",
+    "release:publish": "node scripts/release-npm.mjs publish"
+  },
+  "engines": {
+    "node": ">=22"
+  }
+}

package/scripts/release-npm.mjs

@@ -0,0 +1,202 @@
+import { execFile, spawn } from "node:child_process";
+import { mkdtemp, mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { basename, join, resolve } from "node:path";
+import { tmpdir } from "node:os";
+import { promisify } from "node:util";
+
+const execFileAsync = promisify(execFile);
+
+const ROOT = resolve(new URL("..", import.meta.url).pathname);
+const DIST_DIR = join(ROOT, "dist/npm");
+const PACKAGE_NAMES = ["clankerbend", "@onewillai/clankerbend"];
+
+const command = process.argv[2] || "pack";
+
+if (!["pack", "publish"].includes(command)) {
+  console.error("Usage: node scripts/release-npm.mjs pack|publish");
+  process.exit(2);
+}
+
+try {
+  if (command === "pack") {
+    await packRelease();
+  } else {
+    await publishRelease();
+  }
+} catch (err) {
+  console.error(formatReleaseError(err));
+  process.exit(1);
+}
+
+async function packRelease() {
+  await rm(DIST_DIR, { recursive: true, force: true });
+  await mkdir(DIST_DIR, { recursive: true });
+
+  const basePack = await npm(["pack", "--json", "--pack-destination", DIST_DIR], ROOT);
+  const base = JSON.parse(basePack.stdout)[0];
+  const baseTarball = join(DIST_DIR, base.filename);
+  const scopedTarball = await repackWithName(baseTarball, PACKAGE_NAMES[1]);
+
+  console.log(JSON.stringify({
+    ok: true,
+    packages: [
+      { name: PACKAGE_NAMES[0], tarball: baseTarball },
+      { name: PACKAGE_NAMES[1], tarball: scopedTarball }
+    ]
+  }, null, 2));
+}
+
+async function publishRelease() {
+  const args = process.argv.slice(3);
+  const yes = args.includes("--yes");
+  if (!yes) {
+    console.error("Refusing to publish without --yes. Run `npm run release:publish -- --yes [--otp=123456]`.");
+    process.exit(2);
+  }
+  const otp = args.find((arg) => arg.startsWith("--otp="));
+  const useProvenance = args.includes("--provenance") || isKnownProvenanceCi();
+
+  await packRelease();
+  const rootPackage = JSON.parse(await readFile(join(ROOT, "package.json"), "utf8"));
+  const version = rootPackage.version;
+  const tarballs = [
+    join(DIST_DIR, `clankerbend-${version}.tgz`),
+    join(DIST_DIR, `onewillai-clankerbend-${version}.tgz`)
+  ];
+
+  await npmInteractive(
+    publishArgs(tarballs[1], ["--access", "public"], { otp, useProvenance }),
+    ROOT,
+    { packageName: PACKAGE_NAMES[1] }
+  );
+  await npmInteractive(
+    publishArgs(tarballs[0], [], { otp, useProvenance }),
+    ROOT,
+    { packageName: PACKAGE_NAMES[0] }
+  );
+}
+
+function publishArgs(tarball, extraArgs, { otp, useProvenance }) {
+  const args = ["publish", tarball, ...extraArgs];
+  if (useProvenance) {
+    args.push("--provenance");
+  }
+  if (otp) {
+    args.push(otp);
+  }
+  return args;
+}
+
+function isKnownProvenanceCi() {
+  return Boolean(
+    process.env.GITHUB_ACTIONS ||
+    process.env.GITLAB_CI
+  );
+}
+
+async function repackWithName(tarball, packageName) {
+  const stageRoot = await mkdtemp(join(tmpdir(), "onewhack-npm-release-"));
+  try {
+    await execFileAsync("tar", ["-xzf", tarball, "-C", stageRoot], { cwd: ROOT });
+    const packageDir = join(stageRoot, "package");
+    const packageJsonPath = join(packageDir, "package.json");
+    const packageJson = JSON.parse(await readFile(packageJsonPath, "utf8"));
+    packageJson.name = packageName;
+    await writeFile(packageJsonPath, `${JSON.stringify(packageJson, null, 2)}\n`);
+
+    const output = await npm(["pack", packageDir, "--json", "--pack-destination", DIST_DIR], ROOT);
+    const packed = JSON.parse(output.stdout)[0];
+    return join(DIST_DIR, basename(packed.filename));
+  } finally {
+    await rm(stageRoot, { recursive: true, force: true });
+  }
+}
+
+async function npm(args, cwd) {
+  return execFileAsync("npm", args, {
+    cwd,
+    maxBuffer: 10 * 1024 * 1024,
+    env: process.env
+  });
+}
+
+async function npmInteractive(args, cwd, context = {}) {
+  await new Promise((resolve, reject) => {
+    const stderr = [];
+    const child = spawn("npm", args, {
+      cwd,
+      env: process.env,
+      stdio: ["inherit", "inherit", "pipe"]
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr.push(chunk);
+      process.stderr.write(chunk);
+    });
+    child.on("error", reject);
+    child.on("exit", (code, signal) => {
+      if (code === 0) {
+        resolve();
+        return;
+      }
+      reject(releaseCommandError(args, signal || `exit code ${code}`, {
+        ...context,
+        stderr: Buffer.concat(stderr).toString("utf8")
+      }));
+    });
+  });
+}
+
+function releaseCommandError(args, reason, context) {
+  const err = new Error(`npm ${args.join(" ")} failed with ${reason}`);
+  err.releaseCommand = true;
+  err.args = args;
+  err.reason = reason;
+  err.stderr = context.stderr || "";
+  err.packageName = context.packageName || "";
+  return err;
+}
+
+function formatReleaseError(err) {
+  if (err?.releaseCommand && /That word is not allowed/i.test(err.stderr || "")) {
+    const packageName = err.packageName || "the package";
+    const candidates = candidateNameTokens(packageName);
+    return [
+      "",
+      `npm rejected ${packageName}: "That word is not allowed."`,
+      "",
+      "npm's registry response does not disclose the exact blocked token. The",
+      "only package-name tokens we can identify locally are:",
+      `  ${candidates.map((token) => `- ${token}`).join("\n  ")}`,
+      "",
+      "If npm support has unblocked the name, retry after they confirm the change",
+      "has propagated. Otherwise ask support to allow this exact package id:",
+      `  ${packageName}`,
+      ""
+    ].join("\n");
+  }
+  if (err?.releaseCommand) {
+    return `\n${err.message}\n`;
+  }
+  return err?.stack || String(err);
+}
+
+function candidateNameTokens(packageName) {
+  const withoutScope = packageName.replace(/^@/, "");
+  const tokens = new Set(
+    withoutScope
+      .split(/[\/._-]+/)
+      .flatMap((part) => splitCompoundName(part))
+      .filter(Boolean)
+  );
+  return [...tokens];
+}
+
+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

@@ -0,0 +1,58 @@
+import { pathToFileURL } from "node:url";
+import { createCodexDesktopCdpAdapter } from "./host/src/codex-desktop-cdp-adapter.js";
+import { OneWhackHost, createMockTranscriptAdapter } from "./host/src/index.js";
+import { navigateProfile, printLaunchStatus } from "./launch/profiles.mjs";
+
+export async function launchOneWhackCodex(options = {}) {
+  const mockMode = Boolean(options.mock);
+  const localDevInsecure = options.localDevInsecure === true || process.env.ONEWILL_ONEWHACK_DISABLE_AUTH === "1";
+  const profile = await navigateProfile({
+    stateDir: options.stateDir,
+    runDir: options.runDir,
+    registryConfigPath: options.registryConfigPath,
+    registryProfileId: options.registryProfileId
+  });
+
+  const host = new OneWhackHost({
+    hostId: profile.hostId,
+    hostName: profile.hostName,
+    token: options.token || process.env.ONEWILL_ONEWHACK_TOKEN || undefined,
+    localDevInsecure,
+    runDir: profile.runDir,
+    transcriptAdapter: mockMode
+      ? createMockTranscriptAdapter({ defaultAppId: profile.defaultPanelAppId, providers: profile.providers })
+      : createCodexDesktopCdpAdapter({
+          runDir: profile.runDir,
+          profileDir: profile.runtimePaths?.codexProfileDir,
+          rendererBridges: profile.rendererBridges,
+          providers: profile.providers
+        })
+  });
+
+  for (const app of profile.apps) host.registerApp(app);
+  host.setActivePanelApp(profile.defaultPanelAppId);
+
+  const cleanupAndExit = async (code = 0) => {
+    await host.stop().catch(() => {});
+    process.exit(code);
+  };
+
+  if (options.installSignalHandlers !== false) {
+    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}`);
+      cleanupAndExit(1);
+    });
+  }
+
+  await host.start();
+  printLaunchStatus(profile, host, { mockMode });
+  return { host, profile, mockMode };
+}
+
+if (import.meta.url === pathToFileURL(process.argv[1] || "").href) {
+  await launchOneWhackCodex({
+    mock: process.argv.includes("--mock")
+  });
+}