codiedev 0.9.25 → 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,21 +12,49 @@ 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
 
-- Only sessions inside repos your workspace already tracks
+- Agent sessions from connected devices (capture is enabled by default)
 - 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
+
+Folder exclusions are device-specific and include every child folder. The CLI
+writes the rule locally before attempting to sync its read-only status to the
+portal, so an offline or failed status sync never weakens the exclusion.
+
+```bash
+codiedev ignore ~/Obsidian
+codiedev ignored ~/Obsidian/People   # check whether a path is ignored
+codiedev ignored                     # list every ignored folder
+codiedev unignore ~/Obsidian
+```
+
+Run `ignore` once per device or persistent VM/container. A new ephemeral
+container needs its own rule unless `~/.codiedev/config.json` is persisted.
 
 ## Codex note
 
 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/backup/run.js

@@ -86,6 +86,7 @@ const child_process_1 = require("child_process");
 const utils_1 = require("../utils");
 const cache_2 = require("./cache");
 const push = __importStar(require("../commands/push"));
+const captureExclusions_1 = require("../captureExclusions");
 function gitRoot(cwd) {
     try {
         return (0, child_process_1.execFileSync)("git", ["-C", cwd, "rev-parse", "--show-toplevel"], {
@@ -143,6 +144,8 @@ function runBackup(cwd, hookScriptPath) {
         const config = (0, utils_1.readConfig)();
         if (!config)
             return;
+        if ((0, captureExclusions_1.isCaptureIgnored)(cwd, config.captureIgnoredPaths))
+            return;
         const root = gitRoot(cwd);
         if (!root)
             return;
@@ -195,6 +198,8 @@ async function runBackupUpload(jobFile, deps = DEFAULT_BACKUP_UPLOAD_DEPS) {
         const config = deps.readConfig(); // same machine — read full config from disk
         if (!config)
             return;
+        if ((0, captureExclusions_1.isCaptureIgnored)(job.root, config.captureIgnoredPaths))
+            return;
         const cache = deps.loadCache();
         let dirty = false;
         for (const f of job.files) {

package/dist/captureExclusions.d.ts

@@ -0,0 +1,30 @@
+import type { CodiedevConfig } from "./utils";
+export interface NormalizeCapturePathDeps {
+    cwd?: () => string;
+    homedir?: () => string;
+    realpathSync?: (value: string) => string;
+}
+/**
+ * Convert a user-entered path into the canonical absolute form persisted in
+ * ~/.codiedev/config.json. Existing symlinks resolve to their real target so a
+ * session cannot bypass an exclusion by entering the same folder through a
+ * different alias. Non-existent paths still normalize deterministically.
+ */
+export declare function normalizeCapturePath(input: string, deps?: NormalizeCapturePathDeps): string;
+export declare function findMatchingCaptureExclusion(candidate: string | string[] | undefined, ignoredPaths: string[] | undefined): string | null;
+export declare function isCaptureIgnored(candidate: string | string[] | undefined, ignoredPaths: string[] | undefined): boolean;
+export interface CaptureScopeInput {
+    cwd?: string;
+    workspace_roots?: string[];
+}
+/** Every local root associated with a hook event, deduped in stable order. */
+export declare function captureScopePaths(input: CaptureScopeInput, fallback?: string): string[];
+export declare function shouldIgnoreCaptureInput(config: Pick<CodiedevConfig, "captureIgnoredPaths"> | null | undefined, input: CaptureScopeInput, fallback?: string): boolean;
+/**
+ * Final egress decision for queued transcript uploads. Jobs written by older
+ * CLI versions have no scope metadata; once any exclusion exists, dropping
+ * those legacy jobs is safer than guessing that they are public.
+ */
+export declare function shouldSkipCaptureUploadJob(job: {
+    scopePaths?: string[];
+}, config: Pick<CodiedevConfig, "captureIgnoredPaths"> | null | undefined): boolean;

package/dist/captureExclusions.js

@@ -0,0 +1,118 @@
+"use strict";
+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 });
+exports.normalizeCapturePath = normalizeCapturePath;
+exports.findMatchingCaptureExclusion = findMatchingCaptureExclusion;
+exports.isCaptureIgnored = isCaptureIgnored;
+exports.captureScopePaths = captureScopePaths;
+exports.shouldIgnoreCaptureInput = shouldIgnoreCaptureInput;
+exports.shouldSkipCaptureUploadJob = shouldSkipCaptureUploadJob;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const DEFAULT_NORMALIZE_DEPS = {
+    cwd: () => process.cwd(),
+    homedir: () => os.homedir(),
+    realpathSync: (value) => fs.realpathSync.native(value),
+};
+/**
+ * Convert a user-entered path into the canonical absolute form persisted in
+ * ~/.codiedev/config.json. Existing symlinks resolve to their real target so a
+ * session cannot bypass an exclusion by entering the same folder through a
+ * different alias. Non-existent paths still normalize deterministically.
+ */
+function normalizeCapturePath(input, deps = {}) {
+    const d = { ...DEFAULT_NORMALIZE_DEPS, ...deps };
+    const trimmed = input.trim();
+    if (!trimmed)
+        throw new Error("Folder path is required");
+    const expanded = /^~(?=$|[\\/])/.test(trimmed)
+        ? path.join(d.homedir(), trimmed.slice(1))
+        : trimmed;
+    const absolute = path.resolve(d.cwd(), expanded);
+    try {
+        return path.normalize(d.realpathSync(absolute));
+    }
+    catch {
+        return path.normalize(absolute);
+    }
+}
+function comparisonKey(value) {
+    const normalized = path.normalize(value);
+    return process.platform === "win32" ? normalized.toLowerCase() : normalized;
+}
+function containsPath(root, candidate) {
+    const relative = path.relative(comparisonKey(root), comparisonKey(candidate));
+    return (relative === "" ||
+        (relative !== ".." && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative)));
+}
+function findMatchingCaptureExclusion(candidate, ignoredPaths) {
+    if (!candidate || !ignoredPaths || ignoredPaths.length === 0)
+        return null;
+    const candidates = Array.isArray(candidate) ? candidate : [candidate];
+    for (const ignored of ignoredPaths) {
+        const root = normalizeCapturePath(ignored);
+        for (const value of candidates) {
+            if (containsPath(root, normalizeCapturePath(value)))
+                return root;
+        }
+    }
+    return null;
+}
+function isCaptureIgnored(candidate, ignoredPaths) {
+    return findMatchingCaptureExclusion(candidate, ignoredPaths) !== null;
+}
+/** Every local root associated with a hook event, deduped in stable order. */
+function captureScopePaths(input, fallback = process.cwd()) {
+    const values = [input.cwd, ...(input.workspace_roots ?? [])]
+        .filter((value) => typeof value === "string" && value.length > 0);
+    return [...new Set(values.length > 0 ? values : [fallback])];
+}
+function shouldIgnoreCaptureInput(config, input, fallback) {
+    return isCaptureIgnored(captureScopePaths(input, fallback), config?.captureIgnoredPaths);
+}
+/**
+ * Final egress decision for queued transcript uploads. Jobs written by older
+ * CLI versions have no scope metadata; once any exclusion exists, dropping
+ * those legacy jobs is safer than guessing that they are public.
+ */
+function shouldSkipCaptureUploadJob(job, config) {
+    const ignoredPaths = config?.captureIgnoredPaths ?? [];
+    if (ignoredPaths.length === 0)
+        return false;
+    if (!job.scopePaths || job.scopePaths.length === 0)
+        return true;
+    return isCaptureIgnored(job.scopePaths, ignoredPaths);
+}

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

@@ -33,6 +33,7 @@ const post_1 = require("./commands/post");
 const share_1 = require("./commands/share");
 const send_1 = require("./commands/send");
 const react_1 = require("./commands/react");
+const capture_1 = require("./commands/capture");
 const version_1 = require("./version");
 const HELP = `
 Codiedev CLI
@@ -45,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]
@@ -95,6 +103,11 @@ Feed:
                 [--mention <name>]...    Publish to the team feed
   codiedev react <postId> <emoji>        Toggle a reaction on a feed post
 
+Privacy:
+  codiedev ignore <path>                 Never capture this folder or its children
+  codiedev unignore <path>               Stop ignoring a folder
+  codiedev ignored [path]                List ignored folders, or check one path
+
 Capture:
   codiedev note "<text>"                 Capture a passing thought
 
@@ -130,6 +143,18 @@ Backend: ${process.env.CODIEDEV_URL ?? "https://codiedev.com"}
 Token:   https://codiedev.com/portal/integrations/claude-code
 Docs:    codiedev docs
 `.trim();
+const IGNORE_HELP = `
+codiedev ignore — keep folders out of session capture
+
+  codiedev ignore <path>      Never capture this folder or its children
+  codiedev unignore <path>    Stop ignoring a folder
+  codiedev ignored            List ignored folders on this device
+  codiedev ignored <path>     Check whether a specific path is ignored
+
+Exclusions are per-device and cover every child folder. The rule is written
+locally before any capture leaves your machine, so an offline or failed portal
+status sync never weakens it.
+`.trim();
 const COMMAND_HELP = {
     connect: `
 codiedev connect — link your agent CLI to Codiedev
@@ -237,6 +262,10 @@ codiedev note — capture a passing thought, linked to your session
     codiedev note "idempotency key is worth a follow-up"
     codiedev note "timeout threshold feels arbitrary — validate on slow networks"
 `.trim(),
+    ignore: IGNORE_HELP,
+    unignore: IGNORE_HELP,
+    ignored: IGNORE_HELP,
+    capture: IGNORE_HELP,
     promote: `
 codiedev promote — promote an auto-extracted artifact to authored
 
@@ -482,6 +511,15 @@ async function main() {
             case "react":
                 await (0, react_1.runReact)(rest);
                 return;
+            case "ignore":
+            case "unignore":
+            case "ignored":
+                await (0, capture_1.runCaptureCommand)([command, ...rest]);
+                return;
+            case "capture":
+                // Back-compat alias for the earlier `codiedev capture <sub>` form.
+                await (0, capture_1.runCaptureCommand)(rest);
+                return;
             default:
                 console.error(`Unknown command: ${command}`);
                 console.error(HELP);

package/dist/codie.d.ts

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