oonacode 0.3.13

package/README.md

@@ -0,0 +1,68 @@
+# oonacode (npm wrapper)
+
+OonaCode is a Windows-first, multi-provider coding agent: the genuine Claude Code engine (driven
+through the official Claude Agent SDK) in an isolated profile, sessions in SQLite, any model
+provider through your own gateway, and personal remote access to your own machines.
+
+This package is the **npm/pnpm/bun/yarn entry point**. It contains no binaries itself; the native
+build is pulled in through a per-platform optional dependency and linked into `bin/` by a
+postinstall step (the same model as esbuild / opencode).
+
+```
+npm  install -g oonacode
+pnpm add -g oonacode        # then: pnpm approve-builds   (allow the trusted postinstall)
+bun  add -g oonacode        # then: bun pm trust oonacode
+yarn global add oonacode
+```
+
+Then:
+
+```
+oona --help        # CLI (mirrors Claude Code flags: -p, --model, --output-format text|json|stream-json, --resume, ...)
+oona serve         # start the host service (headless) + local web UI
+oona web           # open the local web UI
+```
+
+## Platform packages
+
+| Platform      | Package               | Status                                   |
+| ------------- | --------------------- | ---------------------------------------- |
+| Windows x64   | `oonacode-win32-x64`  | shipped                                  |
+| Windows arm64 | `oonacode-win32-arm64` | later (x64 build runs under emulation)  |
+| Linux x64     | `oonacode-linux-x64`  | later                                    |
+| Linux arm64   | `oonacode-linux-arm64` | later                                   |
+| macOS x64     | `oonacode-darwin-x64` | later                                    |
+| macOS arm64   | `oonacode-darwin-arm64` | later                                  |
+
+Each platform package carries `oona.exe` (the single-binary host + CLI), `oonaclaude.exe` (the pinned
+Claude Code engine sidecar — it must live on real disk next to `oona.exe`), the local web UI assets
+(`web-ui/`) and native addons (`build/`).
+
+`oonaclaude.exe` is a byte-for-byte copy of the pinned, **unmodified** engine binary from the Claude
+Agent SDK platform package. OonaCode does not fork or patch Claude Code; the file is renamed only so
+it can never be confused with, or collide with, your own `claude` on PATH.
+
+## How `oona` resolves the binary
+
+`bin/oona.js` looks for, in order: `bin/oona.exe` (linked by postinstall) → `oonacode-win32-x64/oona.exe`
+in place → the JS CLI `@oonacode/cli/dist/main.js` when that package is a dependency (developer
+installs; slower start, needs an engine reachable via `OONACODE_CLAUDE_BIN`). The binary runs with
+inherited stdio and its exit code is forwarded verbatim. If nothing is found it prints how to fix
+it, including the Windows one-liner:
+
+```
+irm https://oonacode.oonak.ai/install.ps1 | iex
+```
+
+## Notes
+
+- **pnpm / bun block lifecycle scripts by default.** Without the postinstall the wrapper still
+  works (it resolves the platform package in place); linking only removes one resolution step.
+- Set `OONACODE_SKIP_POSTINSTALL=1` to skip the link step entirely.
+- Your own Claude subscription always runs direct to Anthropic from your PC; API-key providers go
+  through your own OonaCode gateway. No credential is ever shared between users.
+- `private: true` is set on this package until the first publish (TODO: flip in `package.json`
+  once the npm org is ready; the release workflow refuses to publish while it is private).
+- In the monorepo `optionalDependencies` use `workspace:<version>` so pnpm links the sibling
+  platform package; `packaging/scripts/prepare-npm.mjs` rewrites it to the concrete version right
+  before `npm publish` (npm does not understand the workspace protocol).

package/bin/oona.js

@@ -0,0 +1,184 @@
+#!/usr/bin/env node
+'use strict';
+/**
+ * `oona` / `oonacode` — npm wrapper shim.
+ *
+ * Resolution order (first hit wins):
+ *   1. <this package>/bin/oona.exe             — hard-linked/copied there by postinstall.mjs
+ *   2. <platform package>/oona.exe              — e.g. node_modules/oonacode-win32-x64/oona.exe
+ *                                                 (used when the package manager skipped postinstall;
+ *                                                  pnpm/bun block lifecycle scripts unless allowed)
+ *   3. @oonacode/cli/dist/main.js via Node       — JS fallback when the monorepo CLI package is a
+ *                                                 dependency (developer installs); slower to start and
+ *                                                 requires an engine reachable via OONACODE_CLAUDE_BIN.
+ *
+ * The native binary is spawned with inherited stdio and its exit code is forwarded verbatim, so
+ * `oona -p ... --output-format json` works in pipes exactly like the bare executable.
+ *
+ * Windows and Linux x64 are published; the remaining platforms (arm64, darwin) are deferred —
+ * see README.md.
+ */
+const fs = require('fs');
+const path = require('path');
+const { spawn } = require('child_process');
+
+const PLATFORM_PACKAGES = {
+  'win32-x64': '@oonacode/win32-x64',
+  'linux-x64': '@oonacode/linux-x64',
+  // 'win32-arm64': 'oonacode-win32-arm64',   // deferred
+  // 'linux-arm64': 'oonacode-linux-arm64',   // deferred — install.sh refuses aarch64 for the
+  //                                             same reason: nothing is published for it
+  // 'darwin-x64': 'oonacode-darwin-x64',     // deferred
+  // 'darwin-arm64': 'oonacode-darwin-arm64', // deferred
+};
+
+const IS_WIN = process.platform === 'win32';
+const EXE_NAME = IS_WIN ? 'oona.exe' : 'oona';
+// OonaCode ships the engine as `oonaclaude(.exe)`: a byte-for-byte copy of the pinned, UNMODIFIED
+// Claude Code binary from the Claude Agent SDK. We do not fork or patch it — the filename differs
+// only so it can never be confused with, or collide with, the user's own `claude` on PATH.
+// The pre-rename name stays in the list so packages published before the rename still resolve.
+const ENGINE_NAMES = IS_WIN ? ['oonaclaude.exe', 'claude.exe'] : ['oonaclaude', 'claude'];
+const PLATFORM_KEY = `${process.platform}-${process.arch}`;
+
+const INSTALL_HINT = [
+  `oonacode: no native binary found for ${PLATFORM_KEY}.`,
+  '',
+  PLATFORM_PACKAGES[PLATFORM_KEY]
+    ? `  The platform package "${PLATFORM_PACKAGES[PLATFORM_KEY]}" is missing or was installed without its postinstall step.`
+    : `  Prebuilt binaries for ${PLATFORM_KEY} are not published yet (Windows and Linux x64 first).`,
+  '',
+  '  Fixes:',
+  '    - npm:  reinstall with optional dependencies enabled (do not use --no-optional / --omit=optional)',
+  '    - pnpm: allow the trusted postinstall:  pnpm approve-builds  (or add "oonacode" to pnpm.onlyBuiltDependencies)',
+  '    - bun:  bun pm trust oonacode',
+  '    - or install without npm (recommended on Windows):',
+  '          irm https://oonacode.oonak.ai/install.ps1 | iex',
+  '',
+].join('\n');
+
+function exists(p) {
+  try {
+    return fs.existsSync(p);
+  } catch {
+    return false;
+  }
+}
+
+function resolveNative() {
+  const local = path.join(__dirname, EXE_NAME);
+  if (exists(local)) return { bin: local, dir: __dirname };
+
+  const pkg = PLATFORM_PACKAGES[PLATFORM_KEY];
+  if (pkg) {
+    try {
+      const dir = path.dirname(require.resolve(`${pkg}/package.json`));
+      const bin = path.join(dir, EXE_NAME);
+      if (exists(bin)) return { bin, dir };
+    } catch {
+      /* platform package not installed */
+    }
+  }
+  return null;
+}
+
+function resolveBundledJs() {
+  // The documented "node + JS" fallback build ships lib/oona.cjs instead of a compiled oona.exe;
+  // run it with the user's Node (>= 22). Same lookup order as the native binary.
+  const local = path.join(__dirname, 'lib', 'oona.cjs');
+  if (exists(local)) return { script: local, dir: __dirname };
+  const pkg = PLATFORM_PACKAGES[PLATFORM_KEY];
+  if (pkg) {
+    try {
+      const dir = path.dirname(require.resolve(`${pkg}/package.json`));
+      const script = path.join(dir, 'lib', 'oona.cjs');
+      if (exists(script)) return { script, dir };
+    } catch {
+      /* platform package not installed */
+    }
+  }
+  return null;
+}
+
+function resolveJsFallback() {
+  for (const candidate of ['@oonacode/cli/dist/main.js', '@oonacode/cli/bin/oona.js']) {
+    try {
+      return require.resolve(candidate);
+    } catch {
+      /* not a dependency */
+    }
+  }
+  return null;
+}
+
+function engineEnv(env, dirs) {
+  // Make the sidecar engine discoverable even when only oona.exe was linked into ./bin.
+  // OONACODE_CLAUDE_BIN is the documented override read by the host service (packages/shared constants).
+  if (env.OONACODE_CLAUDE_BIN) return env;
+  for (const dir of dirs) {
+    for (const name of ENGINE_NAMES) {
+      const candidate = path.join(dir, name);
+      if (exists(candidate)) {
+        env.OONACODE_CLAUDE_BIN = candidate;
+        return env;
+      }
+    }
+  }
+  return env;
+}
+
+function run() {
+  const args = process.argv.slice(2);
+  const env = { ...process.env };
+  let child;
+
+  const native = resolveNative();
+  const bundled = native ? null : resolveBundledJs();
+  if (native) {
+    engineEnv(env, [native.dir, __dirname]);
+    child = spawn(native.bin, args, { stdio: 'inherit', env, windowsHide: false });
+  } else if (bundled) {
+    engineEnv(env, [bundled.dir, __dirname]);
+    child = spawn(process.execPath, [bundled.script, ...args], {
+      stdio: 'inherit',
+      env,
+      windowsHide: false,
+    });
+  } else {
+    const js = resolveJsFallback();
+    if (!js) {
+      process.stderr.write(INSTALL_HINT);
+      process.exit(1);
+    }
+    engineEnv(env, [__dirname]);
+    child = spawn(process.execPath, [js, ...args], { stdio: 'inherit', env, windowsHide: false });
+  }
+
+  const forward = (signal) => {
+    try {
+      child.kill(signal);
+    } catch {
+      /* already gone */
+    }
+  };
+  for (const signal of ['SIGINT', 'SIGTERM', 'SIGHUP']) {
+    process.on(signal, () => forward(signal));
+  }
+
+  child.on('error', (err) => {
+    process.stderr.write(
+      `oonacode: failed to start ${native ? native.bin : 'the JS CLI'}: ${err.message}\n`,
+    );
+    process.exit(1);
+  });
+  child.on('exit', (code, signal) => {
+    if (signal) {
+      // Mirror a signal death as the conventional 128+n exit code (130 for SIGINT).
+      const n = require('os').constants.signals[signal] || 0;
+      process.exit(128 + n);
+    }
+    process.exit(code == null ? 1 : code);
+  });
+}
+
+run();

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "oonacode",
+  "version": "0.3.13",
+  "description": "OonaCode \u2014 Windows-first multi-provider coding agent: the `oona` CLI, headless host service and local web UI. npm wrapper; the native binary is installed through the per-platform optional dependency.",
+  "license": "UNLICENSED",
+  "type": "commonjs",
+  "homepage": "https://oonacode.oonak.ai",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/oonak-ai/oonacode.git",
+    "directory": "packaging/npm/oonacode"
+  },
+  "keywords": [
+    "oonacode",
+    "oona",
+    "coding-agent",
+    "claude",
+    "cli",
+    "ai"
+  ],
+  "engines": {
+    "node": ">=22"
+  },
+  "bin": {
+    "oona": "bin/oona.js",
+    "oonacode": "bin/oona.js"
+  },
+  "files": [
+    "bin/oona.js",
+    "postinstall.mjs",
+    "README.md"
+  ],
+  "scripts": {
+    "postinstall": "node postinstall.mjs",
+    "test": "node --test test/wrapper.test.js test/packaging-scripts.test.js test/release-feed.test.js test/manifests.test.js test/set-version.test.js"
+  },
+  "optionalDependencies": {
+    "@oonacode/win32-x64": "0.3.13",
+    "@oonacode/linux-x64": "0.3.13"
+  }
+}

package/postinstall.mjs

@@ -0,0 +1,143 @@
+/**
+ * oonacode postinstall — link the platform-specific native binaries into ./bin so that
+ * `oona` starts without a resolution step.
+ *
+ *   node_modules/oonacode-win32-x64/oona.exe        ->  ./bin/oona.exe        (hard link, falls back to copy)
+ *   node_modules/oonacode-win32-x64/oonaclaude.exe  ->  ./bin/oonaclaude.exe  (engine sidecar — must sit next to oona.exe)
+ *   node_modules/oonacode-win32-x64/web-ui/         ->  ./bin/web-ui/         (directory junction, falls back to copy)
+ *   node_modules/oonacode-win32-x64/build/          ->  ./bin/build/          (native addons, same treatment)
+ *
+ * `oonaclaude(.exe)` is a byte-for-byte copy of the pinned, UNMODIFIED Claude Code binary from the
+ * Claude Agent SDK. OonaCode does not fork or patch it — the filename differs only so it can never be
+ * confused with, or collide with, the user's own `claude` on PATH.
+ *
+ * This script NEVER fails the install: when the platform package is missing (unsupported platform,
+ * --no-optional, blocked lifecycle scripts) it prints a hint and exits 0. bin/oona.js resolves the
+ * platform package in place at runtime anyway and prints the same hint if nothing is available.
+ *
+ * Skipped silently when OONACODE_SKIP_POSTINSTALL=1 or when running inside the oonacode monorepo
+ * (the platform package there is a skeleton without binaries until the release workflow injects them).
+ */
+import { createRequire } from 'node:module';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const here = path.dirname(fileURLToPath(import.meta.url));
+const require = createRequire(import.meta.url);
+
+const PLATFORM_PACKAGES = {
+  'win32-x64': '@oonacode/win32-x64',
+  // Linux joined on 2026-09-07, when the npm channel was opened: `bin/oona.js` already resolved
+  // it at runtime, but without an entry here the postinstall linked nothing, so a Linux install
+  // had to pay the resolve on every invocation instead of once.
+  'linux-x64': '@oonacode/linux-x64',
+};
+const IS_WIN = process.platform === 'win32';
+const EXE_NAME = IS_WIN ? 'oona.exe' : 'oona';
+const ENGINE_NAME = IS_WIN ? 'oonaclaude.exe' : 'oonaclaude';
+/** Pre-rename filename, still linked when a package published before the rename is installed. */
+const LEGACY_ENGINE_NAME = IS_WIN ? 'claude.exe' : 'claude';
+const LINKED_DIRS = ['web-ui', 'build', 'prebuilds', 'lib'];
+
+const log = (msg) => console.log(`[oonacode] ${msg}`);
+const INSTALL_HINT =
+  'Install the native build with:  irm https://oonacode.oonak.ai/install.ps1 | iex   (Windows)\n' +
+  '[oonacode] or re-run the install with optional dependencies + postinstall scripts enabled ' +
+  '(pnpm: `pnpm approve-builds`, bun: `bun pm trust oonacode`).';
+
+function insideMonorepo() {
+  const root = path.resolve(here, '..', '..', '..');
+  return (
+    fs.existsSync(path.join(root, 'pnpm-workspace.yaml')) &&
+    fs.existsSync(path.join(root, 'packages', 'shared'))
+  );
+}
+
+function linkFile(src, dst) {
+  fs.rmSync(dst, { force: true });
+  try {
+    fs.linkSync(src, dst);
+    return 'hard-linked';
+  } catch {
+    fs.copyFileSync(src, dst);
+    return 'copied';
+  }
+}
+
+function linkDir(src, dst) {
+  fs.rmSync(dst, { recursive: true, force: true });
+  try {
+    fs.symlinkSync(src, dst, 'junction'); // junction: no admin rights needed on Windows
+    return 'linked';
+  } catch {
+    fs.cpSync(src, dst, { recursive: true });
+    return 'copied';
+  }
+}
+
+function main() {
+  if (process.env.OONACODE_SKIP_POSTINSTALL === '1') return;
+  if (insideMonorepo()) return;
+
+  const key = `${process.platform}-${process.arch}`;
+  const pkgName = PLATFORM_PACKAGES[key];
+  if (!pkgName) {
+    log(
+      `no prebuilt binary is published for ${key} yet (Windows x64 first; macOS/Linux deferred).`,
+    );
+    log(INSTALL_HINT);
+    return;
+  }
+
+  let pkgDir;
+  try {
+    pkgDir = path.dirname(require.resolve(`${pkgName}/package.json`));
+  } catch {
+    log(`platform package "${pkgName}" is not installed (optional dependencies disabled?).`);
+    log(INSTALL_HINT);
+    return;
+  }
+
+  const exeSrc = path.join(pkgDir, EXE_NAME);
+  const bundledJs = path.join(pkgDir, 'lib', 'oona.cjs');
+  if (!fs.existsSync(exeSrc) && !fs.existsSync(bundledJs)) {
+    log(`"${pkgName}" is installed but contains no ${EXE_NAME} (pre-release skeleton?).`);
+    log(INSTALL_HINT);
+    return;
+  }
+
+  const binDir = path.join(here, 'bin');
+  fs.mkdirSync(binDir, { recursive: true });
+
+  const parts = [];
+  if (fs.existsSync(exeSrc))
+    parts.push(`${EXE_NAME} ${linkFile(exeSrc, path.join(binDir, EXE_NAME))}`);
+  // Link whichever engine filename the platform package carries; ours first, the pre-rename one
+  // second so an older published platform package still yields a working sidecar.
+  const engineName = [ENGINE_NAME, LEGACY_ENGINE_NAME].find((name) =>
+    fs.existsSync(path.join(pkgDir, name)),
+  );
+  if (engineName) {
+    parts.push(
+      `${engineName} ${linkFile(path.join(pkgDir, engineName), path.join(binDir, engineName))}`,
+    );
+  } else {
+    log(
+      `warning: ${ENGINE_NAME} engine sidecar not found in ${pkgName}; \`oona doctor\` will flag it.`,
+    );
+  }
+  for (const dir of LINKED_DIRS) {
+    const src = path.join(pkgDir, dir);
+    if (fs.existsSync(src)) parts.push(`${dir}/ ${linkDir(src, path.join(binDir, dir))}`);
+  }
+  log(`ready: ${parts.join(', ')} -> ${binDir}`);
+}
+
+try {
+  main();
+} catch (err) {
+  log(`postinstall could not link the native binary: ${err && err.message ? err.message : err}`);
+  log(INSTALL_HINT);
+}
+process.exitCode = 0;