codiedev 0.9.26 → 0.9.28

package/README.md

@@ -1,6 +1,6 @@
 # codiedev
 
-Connect Claude Code or Codex to Codiedev for org-wide session capture.
+Connect Claude Code, Codex, Cursor, or OpenCode to Codiedev for team session capture.
 
 ## Usage
 
@@ -12,8 +12,12 @@ The CLI will prompt you for an API token (get one at https://codiedev.com/portal
 
 - **Claude Code** — `SessionEnd` hook in `~/.claude/settings.json`
 - **Codex** — `Stop` hook in `~/.codex/hooks.json`
+- **Cursor** — `sessionEnd` hook in `~/.cursor/hooks.json`
+- **OpenCode / Codie** — plugin in `~/.config/opencode/plugins/codiedev.js`
 
-If both are installed, hooks are wired up for both. If neither is installed, the config is saved and you can re-run `connect` after installing one.
+Installed clients are wired automatically. The OpenCode adapter is staged even
+when OpenCode is not installed yet, so adding the Codie harness later does not
+require a second connect step.
 
 ## What gets captured
 
@@ -21,7 +25,9 @@ If both are installed, hooks are wired up for both. If neither is installed, the
 - Transcript + basic stats (message count, tool calls)
 - Processed into summaries and embeddings server-side for search in `/portal/memories`
 
-Each captured memory records its `source` (`claude-code` or `codex`) so you can filter in the portal.
+Each captured memory records its source (`claude-code`, `codex`, `cursor`, or
+`opencode`) so the portal can label the client without breaking the shared
+session → repository / branch / SHA → merge attribution model.
 
 ## Keep folders local
 
@@ -43,6 +49,12 @@ container needs its own rule unless `~/.codiedev/config.json` is persisted.
 
 Codex doesn't currently expose a `SessionEnd` event, so the hook runs on `Stop` (fires after each assistant turn). The backend dedupes by `(company, session_id)` and replaces the stored transcript on re-upload so the latest turn's snapshot wins. Summarization happens once per session; subsequent turn uploads keep the raw transcript fresh but don't re-summarize (to avoid running up LLM cost).
 
+## OpenCode note
+
+OpenCode exposes session lifecycle events through plugins. Codiedev snapshots
+the SDK message list on `session.idle`, normalizes it into the shared capture
+pipeline, and lets the server close the session after a quiet-period lease.
+
 ## Config
 
 Written to `~/.codiedev/config.json`. Override the backend with `CODIEDEV_URL` if needed.

package/assets/opencode-plugin.mjs

@@ -0,0 +1,54 @@
+// Metadata-only attribution for the Codiedev OpenCode distribution.
+// This plugin never reads or sends prompts, messages, code, diffs, or tool
+// output. It only attaches stable session/git identifiers and explicit skill
+// names to inference requests handled by the company gateway.
+
+const skillUseBySession = new Map();
+
+function clean(value, max) {
+  const text = typeof value === "string" ? value.trim() : "";
+  return text ? text.slice(0, max) : "";
+}
+
+function addSkill(sessionID, value) {
+  const skill = clean(value, 160).replace(/^\//, "").replace(/\.md$/i, "");
+  if (!skill) return;
+  const skills = skillUseBySession.get(sessionID) || new Set();
+  if (skills.size < 50) skills.add(skill);
+  skillUseBySession.set(sessionID, skills);
+}
+
+export const CodiedevMetadata = async () => ({
+  "command.execute.before": async (input) => {
+    // Built-in commands are UI actions. Named custom commands are explicit
+    // skill dispatches and become part of the session attribution spine.
+    const builtIns = new Set([
+      "connect", "help", "models", "new", "share", "unshare", "undo", "redo",
+      "compact", "sessions", "timeline", "themes", "editor", "export", "exit",
+    ]);
+    if (!builtIns.has(input.command)) addSkill(input.sessionID, input.command);
+  },
+  "tool.execute.before": async (input, output) => {
+    if (input.tool !== "skill") return;
+    addSkill(input.sessionID, output.args?.name || output.args?.skill || output.args?.key);
+  },
+  "chat.headers": async (input, output) => {
+    output.headers["X-Codiedev-Session-Id"] = clean(input.sessionID, 200);
+    const repo = clean(process.env.CODIEDEV_REPO_URL, 2048);
+    const branch = clean(process.env.CODIEDEV_BRANCH, 200);
+    const sha = clean(process.env.CODIEDEV_HEAD_SHA, 40);
+    const user = clean(process.env.CODIEDEV_USER, 200);
+    const skills = [...(skillUseBySession.get(input.sessionID) || [])].join(",");
+    if (repo) output.headers["X-Codiedev-Repo-Url"] = repo;
+    if (branch) output.headers["X-Codiedev-Branch"] = branch;
+    if (/^[0-9a-f]{7,40}$/i.test(sha)) output.headers["X-Codiedev-Head-Sha"] = sha;
+    if (user) output.headers["X-Codiedev-User"] = user;
+    if (skills) output.headers["X-Codiedev-Skills-Used"] = skills;
+  },
+  event: async ({ event }) => {
+    if (event?.type === "session.deleted") {
+      const sessionID = event.properties?.info?.id || event.properties?.sessionID;
+      if (sessionID) skillUseBySession.delete(sessionID);
+    }
+  },
+});

package/assets/tui-brand-plugin.tsx

@@ -0,0 +1,63 @@
+/** @jsxImportSource @opentui/solid */
+// Codiedev branding for the OpenCode home screen: the intertwined c/d brand
+// mark (rectangle crop, sized to the footprint the stock wordmark occupied)
+// over the product name, with a "powered by opencode" credit line beneath.
+// Installed and kept current by `codie`; deleting this file and its tui.json
+// entry restores the stock logo.
+// Mark ported from the retired Grok-fork TUI (assets/logo/logo07.txt), itself
+// derived from vm-demo/public/codiedev-icon.png — keep aligned to that
+// intertwined c/d silhouette when refreshing brand assets.
+import type { TuiPlugin, TuiPluginModule } from "@opencode-ai/plugin/tui"
+import { TextAttributes } from "@opentui/core"
+
+const MARK = [
+  "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣿⣿⣿",
+  "⠀⠀⠀⢀⣀⣀⣀⡀⠀⠀⠀⠀⠀⣀⣀⣀⡀⣿⣿⣿",
+  "⠀⣠⣾⣿⣿⣿⣿⣿⣶⠄⢠⣶⣿⣿⣿⣿⣿⣿⣿⣿",
+  "⣼⣿⣿⠟⠉⠈⠉⠛⠁⣰⣿⣿⡟⠉⠁⠉⠻⣿⣿⣿",
+  "⣿⣿⣿⠀⠀⠀⠀⢀⣼⣿⣿⣿⡀⠀⠀⠀⠀⣿⣿⣿",
+  "⠹⣿⣿⣷⣤⣤⣴⣿⣿⡿⢿⣿⣷⣤⣤⣤⣾⣿⣿⠏",
+  "⠀⠈⠻⢿⣿⣿⣿⠿⠋⠀⠀⠙⠿⣿⣿⣿⡿⠟⠁",
+]
+
+const tui: TuiPlugin = async (api) => {
+  api.slots.register({
+    slots: {
+      home_logo(ctx) {
+        const theme = ctx.theme.current
+        return (
+          <box flexDirection="column" alignItems="center" gap={1}>
+            <box flexDirection="column">
+              {MARK.map((line) => (
+                <text fg={theme.primary} selectable={false}>
+                  {line}
+                </text>
+              ))}
+            </box>
+            <box flexDirection="column" alignItems="center">
+              <box flexDirection="row">
+                <text fg={theme.text} attributes={TextAttributes.BOLD} selectable={false}>
+                  codiedev
+                </text>
+                <text fg={theme.textMuted} selectable={false}>
+                  {" "}
+                  harness
+                </text>
+              </box>
+              <text fg={theme.textMuted} selectable={false}>
+                powered by opencode
+              </text>
+            </box>
+          </box>
+        )
+      },
+    },
+  })
+}
+
+const plugin: TuiPluginModule & { id: string } = {
+  id: "codiedev.brand",
+  tui,
+}
+
+export default plugin

package/dist/backup/cache.js

@@ -38,9 +38,9 @@ exports.loadCache = loadCache;
 exports.saveCache = saveCache;
 exports.applyCache = applyCache;
 const fs = __importStar(require("fs"));
-const os = __importStar(require("os"));
 const path = __importStar(require("path"));
-const CACHE_PATH = path.join(os.homedir(), ".codiedev", "backup-state.json");
+const configDir_1 = require("../configDir");
+const CACHE_PATH = path.join((0, configDir_1.codiedevStateDir)(), "backup-state.json");
 function cacheKey(repoKey, rel) {
     return `${repoKey}::${rel}`;
 }

package/dist/captureLog.js

@@ -36,7 +36,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.CAPTURE_LOG_PATH = exports.CAPTURE_LOG_MAX_BYTES = void 0;
 exports.appendCaptureLog = appendCaptureLog;
 exports.readCaptureLogTail = readCaptureLogTail;
-// Rotating capture diagnostic log at ~/.codiedev/capture.log.
+// Rotating capture diagnostic log at <codiedevStateDir()>/capture.log
+// (~/.codiedev by default; ~/.codiedev-desktop under CODIEDEV_CONFIG_DIR).
 //
 // Every stage of the capture pipeline (capture-finish child, upload child,
 // stderr from detached children) writes one line here so users — and
@@ -45,12 +46,14 @@ exports.readCaptureLogTail = readCaptureLogTail;
 // best-effort throughout: appendCaptureLog NEVER throws into the hook path.
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
-const os = __importStar(require("os"));
+// Imported from configDir (not utils) — utils.ts imports this module, so
+// importing utils.ts here would create a circular import.
+const configDir_1 = require("./configDir");
 // Rotate the log when it exceeds this size (keeps the newest ~half). 256 KB
 // holds thousands of entries; a user would have to see hundreds of errors
 // before hitting this limit, so it's a generous safety valve.
 exports.CAPTURE_LOG_MAX_BYTES = 256 * 1024;
-exports.CAPTURE_LOG_PATH = path.join(os.homedir(), ".codiedev", "capture.log");
+exports.CAPTURE_LOG_PATH = path.join((0, configDir_1.codiedevStateDir)(), "capture.log");
 // Append one structured line to the capture log. Rotates the file when it
 // grows past CAPTURE_LOG_MAX_BYTES by truncating it to the newest half (keeps
 // the most recent diagnostics). Best-effort: NEVER throws into the hook path —

package/dist/cli.js

@@ -46,6 +46,13 @@ Connect:
   codiedev connect                       Link Claude Code / Codex to your org
   codiedev doctor                        Verify your setup after connecting
 
+Harness:
+  codie                                  Launch the governed Codie harness.
+                                         Same install, same token as above —
+                                         use your own agent (Claude Code,
+                                         Codex, Cursor) or Codie, your call.
+                                         The engine downloads on first run.
+
 Artifacts:
   codiedev push <file.md>                Author or update an artifact
   codiedev pull <key> [--version N] [--out path]

package/dist/codie.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/codie.js

@@ -0,0 +1,233 @@
+#!/usr/bin/env node
+"use strict";
+// `codie` — Codiedev's governed coding harness.
+//
+// Ships from the same package as `codiedev` so a developer runs one install and
+// then picks their surface: Claude Code, Codex, and Cursor get session capture
+// via `codiedev connect`; `codie` launches the governed harness against the
+// same token. OpenCode is the embedded engine; all user-facing identity,
+// credentials, models, policy, and capture belong to Codiedev.
+//
+// The engine is downloaded on first run (see codieRuntime.ts) so capture-only
+// users never pay for it.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const url_1 = require("url");
+const configDir_1 = require("./configDir");
+const codieLauncher_1 = require("./codieLauncher");
+const codieRuntime_1 = require("./codieRuntime");
+const codieRuntimeInstall_1 = require("./codieRuntimeInstall");
+function git(args) {
+    const result = (0, child_process_1.spawnSync)("git", args, { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
+    return result.status === 0 ? result.stdout.trim() : "";
+}
+function safeRepoUrl(value) {
+    if (!value)
+        return "";
+    try {
+        const url = new URL(value);
+        url.username = "";
+        url.password = "";
+        return url.toString();
+    }
+    catch {
+        return value.replace(/^[^@\s]+@(?=[^:/\s]+[:/])/, "");
+    }
+}
+function existingInlineConfig() {
+    const raw = process.env.OPENCODE_CONFIG_CONTENT;
+    if (!raw)
+        return {};
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        throw new Error("OPENCODE_CONFIG_CONTENT is not valid JSON");
+    }
+}
+// The one credential. `codiedev connect` wrote it; the gateway validates the
+// same userApiTokens row, so there is no second harness token to mint.
+function connectedCodiedevConfig() {
+    try {
+        return JSON.parse(fs.readFileSync(path.join((0, configDir_1.codiedevStateDir)(), "config.json"), "utf8"));
+    }
+    catch {
+        return {};
+    }
+}
+function assetPath(name) {
+    // dist/codie.js → ../assets/<name>; src/codie.ts → ../assets/<name>.
+    return path.join(__dirname, "..", "assets", name);
+}
+// Stage the home-screen branding plugin. TUI plugins only load from tui.json
+// in the OpenCode config dir, so the packaged file is copied next to the
+// capture plugin and referenced with a relative spec. Best-effort: any
+// failure (e.g. a hand-edited tui.json with comments) leaves the stock logo.
+function installBrandPlugin() {
+    try {
+        // OpenCode resolves its config dir per the XDG spec, so a customized
+        // XDG_CONFIG_HOME must be honored or tui.json lands where it never reads.
+        const configDir = path.join(process.env.XDG_CONFIG_HOME?.trim() || path.join(os.homedir(), ".config"), "opencode");
+        const pluginDir = path.join(configDir, "plugins");
+        fs.mkdirSync(pluginDir, { recursive: true });
+        const source = fs.readFileSync(assetPath("tui-brand-plugin.tsx"), "utf8");
+        const destination = path.join(pluginDir, "codiedev-brand.tsx");
+        if (!fs.existsSync(destination) || fs.readFileSync(destination, "utf8") !== source) {
+            fs.writeFileSync(destination, source);
+        }
+        const tuiConfigPath = path.join(configDir, "tui.json");
+        const existing = fs.existsSync(tuiConfigPath) ? JSON.parse(fs.readFileSync(tuiConfigPath, "utf8")) : {};
+        const { config, changed } = (0, codieLauncher_1.withBrandPlugin)(existing);
+        if (changed)
+            fs.writeFileSync(tuiConfigPath, `${JSON.stringify(config, null, 2)}\n`);
+    }
+    catch (error) {
+        console.error(`codie: continuing without Codiedev branding (${error instanceof Error ? error.message : error})`);
+    }
+}
+// Remove the engine's boot/exit banner wordmark in place (see
+// patchBrandWordmark). Best-effort like the TUI plugin: any failure rolls the
+// bytes back and the stock banner keeps working. Runs once per install; an
+// already-suppressed binary has no known source region and is skipped.
+function installBrandWordmark(runtime) {
+    try {
+        installBrandWordmarkUnsafe(runtime);
+    }
+    catch (error) {
+        console.error(`codie: continuing with the stock banner (${error instanceof Error ? error.message : error})`);
+    }
+}
+function installBrandWordmarkUnsafe(runtime) {
+    const binary = fs.readFileSync(runtime);
+    const { changed, offset, replacement } = (0, codieLauncher_1.patchBrandWordmark)(binary);
+    if (!changed || !replacement)
+        return;
+    // In-place write (not copy+rename): opencode-ai/bin/opencode.exe and the
+    // platform package's binary are hardlinks to one inode, and this keeps them
+    // consistent. Restoring the original bytes is a true rollback — identical
+    // content revalidates the existing macOS signature.
+    const writeAt = (bytes) => {
+        const fd = fs.openSync(runtime, "r+");
+        try {
+            fs.writeSync(fd, bytes, 0, bytes.length, offset);
+        }
+        finally {
+            fs.closeSync(fd);
+        }
+    };
+    const restore = () => writeAt(binary.subarray(offset, offset + replacement.length));
+    writeAt(replacement);
+    if (process.platform === "darwin") {
+        // A modified Mach-O needs a fresh ad-hoc signature or the OS kills it.
+        const signed = (0, child_process_1.spawnSync)("codesign", ["--force", "--sign", "-", runtime], { stdio: "ignore" });
+        if (signed.status !== 0) {
+            restore();
+            return;
+        }
+    }
+    const probe = (0, child_process_1.spawnSync)(runtime, ["--version"], { stdio: "ignore", timeout: 30000 });
+    if (probe.status !== 0) {
+        restore();
+        if (process.platform === "darwin")
+            (0, child_process_1.spawnSync)("codesign", ["--force", "--sign", "-", runtime], { stdio: "ignore" });
+    }
+}
+async function main() {
+    (0, codieRuntime_1.assertCodieNodeVersion)(process.versions.node);
+    const connected = connectedCodiedevConfig();
+    const key = process.env.CODIEDEV_GATEWAY_KEY ||
+        process.env.CODIEDEV_TOKEN ||
+        (typeof connected.token === "string" ? connected.token.trim() : "");
+    if (!key) {
+        throw new Error("Connect your Codiedev account first with `codiedev connect`");
+    }
+    const gatewayUrl = process.env.CODIEDEV_GATEWAY_URL || "https://gateway.codiedev.com/api/v1";
+    const catalog = await (0, codieLauncher_1.fetchApprovedCatalog)({ baseUrl: gatewayUrl, key });
+    const parsed = (0, codieLauncher_1.parseCodieArgs)(process.argv.slice(2));
+    if (parsed.args.length === 1 && parsed.args[0] === "models") {
+        console.log("Codiedev approved models\n");
+        catalog.forEach((model) => console.log(`  ${model.id.padEnd(38)} ${model.name || ""}`));
+        return;
+    }
+    (0, codieLauncher_1.validateCodieArgs)(parsed.args, catalog);
+    const stateDir = (0, configDir_1.codiedevStateDir)();
+    const runtime = (0, codieRuntimeInstall_1.ensureCodieRuntimeBinary)({
+        resolve: () => (0, codieRuntime_1.resolveCodieRuntime)({
+            env: process.env,
+            stateDir,
+            existsSync: (candidate) => fs.existsSync(candidate),
+            resolveBundled: () => {
+                try {
+                    return require.resolve("opencode-ai/bin/opencode.exe");
+                }
+                catch {
+                    return null;
+                }
+            },
+        }),
+        install: (missing) => (0, codieRuntimeInstall_1.installCodieRuntimeOnDisk)(missing, stateDir),
+    });
+    const metadataPlugin = (0, url_1.pathToFileURL)(assetPath("opencode-plugin.mjs")).href;
+    const capturePlugin = (0, codieLauncher_1.resolveCapturePlugin)({ homeDir: os.homedir(), existsSync: fs.existsSync });
+    installBrandPlugin();
+    installBrandWordmark(runtime);
+    const config = (0, codieLauncher_1.buildCodieConfig)({
+        existing: existingInlineConfig(),
+        catalog,
+        env: { ...process.env, ...parsed.overrides, CODIEDEV_GATEWAY_URL: gatewayUrl },
+        plugins: [capturePlugin, metadataPlugin],
+    });
+    const env = {
+        ...process.env,
+        ...parsed.overrides,
+        CODIEDEV_GATEWAY_KEY: key,
+        CODIEDEV_REPO_URL: safeRepoUrl(git(["remote", "get-url", "origin"])),
+        CODIEDEV_BRANCH: git(["branch", "--show-current"]),
+        CODIEDEV_HEAD_SHA: git(["rev-parse", "HEAD"]),
+        OPENCODE_CONFIG_CONTENT: JSON.stringify(config),
+    };
+    const result = (0, child_process_1.spawnSync)(runtime, parsed.args, { stdio: "inherit", env });
+    if (result.error)
+        throw result.error;
+    process.exitCode = result.status === null ? 1 : result.status;
+}
+main().catch((error) => {
+    console.error(`codie: ${error instanceof Error ? error.message : String(error)}`);
+    process.exitCode = 1;
+});

package/dist/codieLauncher.d.ts

@@ -0,0 +1,41 @@
+export interface CatalogModel {
+    id: string;
+    name?: string;
+}
+export declare function bareModel(value: unknown): string;
+export declare function buildCodieConfig({ existing, catalog, env, plugin, plugins, }: {
+    existing?: Record<string, any>;
+    catalog: CatalogModel[];
+    env?: Record<string, string | undefined>;
+    plugin?: string;
+    plugins?: string[];
+}): Record<string, any>;
+export declare const BRAND_PLUGIN_SPEC = "./plugins/codiedev-brand.tsx";
+export declare function withBrandPlugin(existing: Record<string, any> | undefined): {
+    config: Record<string, any>;
+    changed: boolean;
+};
+export declare const STOCK_WORDMARK: string;
+export declare const LEGACY_CODIEDEV_WORDMARK: string;
+export declare const CODIEDEV_WORDMARK: string;
+export declare const HIDDEN_WORDMARK: string;
+export declare function patchBrandWordmark(binary: Buffer): {
+    changed: boolean;
+    offset: number;
+    stock: Buffer;
+    replacement: Buffer | null;
+};
+export declare function resolveCapturePlugin({ homeDir, existsSync, }: {
+    homeDir: string;
+    existsSync: (candidate: string) => boolean;
+}): string;
+export declare function fetchApprovedCatalog({ baseUrl, key, fetchImpl, }: {
+    baseUrl?: string;
+    key: string;
+    fetchImpl?: typeof fetch;
+}): Promise<CatalogModel[]>;
+export declare function parseCodieArgs(argv: string[]): {
+    args: string[];
+    overrides: Record<string, string>;
+};
+export declare function validateCodieArgs(args: string[], catalog: CatalogModel[]): void;