@addai/node 0.4.0

package/dist/git-identity.js

@@ -0,0 +1,104 @@
+"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.applyGitIdentity = applyGitIdentity;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const supabase_client_1 = require("./supabase-client");
+/**
+ * Give a freshly cloned repo the ENTITY's git identity, and optionally credit
+ * the person who asked for the work.
+ *
+ * Without this, commits land under whatever global git config the host machine
+ * happens to have — usually the machine's owner, which is wrong and confusing
+ * when several entities share a node.
+ *
+ * Identity comes from runtime_get_git_identity rather than the request row: six
+ * different RPCs create those rows and threading two more columns through all of
+ * them is needless fragility.
+ *
+ * On avatars: GitHub derives a commit's avatar from the email, so an entity's
+ * own photo cannot appear there without a real GitHub account per entity. The
+ * co-author trailer is what puts a real avatar and a real GitHub identity on the
+ * commit, which is why it defaults on.
+ */
+async function applyGitIdentity(dir, requestId, token) {
+    let ident = null;
+    try {
+        ident = await (0, supabase_client_1.rpc)('runtime_get_git_identity', { p_token: token, p_request_id: requestId });
+    }
+    catch {
+        return; // never fail a clone over commit cosmetics
+    }
+    if (!ident?.configured || !ident.author_name || !ident.author_email)
+        return;
+    const git = (args) => new Promise((resolve) => {
+        (0, child_process_1.execFile)('git', ['-C', dir, ...args], { timeout: 10_000 }, () => resolve());
+    });
+    // Repo-local only — never touch the machine's global config, which other
+    // entities and the human owner share.
+    await git(['config', 'user.name', ident.author_name]);
+    await git(['config', 'user.email', ident.author_email]);
+    if (!ident.coauthor)
+        return;
+    // A prepare-commit-msg hook, not commit.template: templates are ignored by
+    // `git commit -m`, which is how an agent always commits. The hook appends the
+    // trailer only when it is not already present, so amends stay idempotent.
+    try {
+        const hooksDir = path.join(dir, '.git', 'hooks');
+        fs.mkdirSync(hooksDir, { recursive: true });
+        const hook = path.join(hooksDir, 'prepare-commit-msg');
+        const trailer = `Co-authored-by: ${ident.coauthor}`;
+        const script = [
+            '#!/bin/sh',
+            '# Written by +Ai entity-runtime: credit the person who asked for the work.',
+            'MSG_FILE="$1"',
+            `TRAILER=${JSON.stringify(trailer)}`,
+            'grep -qF "$TRAILER" "$MSG_FILE" 2>/dev/null && exit 0',
+            'printf "\\n%s\\n" "$TRAILER" >> "$MSG_FILE"',
+            '',
+        ].join('\n');
+        fs.writeFileSync(hook, script, { mode: 0o755 });
+        // Windows checkouts ignore the mode bit; chmod is a harmless no-op there.
+        try {
+            fs.chmodSync(hook, 0o755);
+        }
+        catch { /* non-POSIX */ }
+    }
+    catch {
+        /* identity still applied; the trailer is a nice-to-have */
+    }
+}

package/dist/grok-binary.d.ts

@@ -0,0 +1,4 @@
+/** Forget the cached lookup — call after an install so a fresh probe
+ *  can see a binary that was missing at daemon start. */
+export declare function resetCache(): void;
+export declare function findGrokBinary(): string | null;

package/dist/grok-binary.js

@@ -0,0 +1,70 @@
+"use strict";
+// Locate the `grok` binary on the host. The xAI installer drops it at
+// ~/.local/bin/grok by default, but it can also live on PATH or under
+// /usr/local/bin, /opt/homebrew/bin, or ~/.grok/bin depending on how the
+// user installed it. On Windows: grok.exe in the same user-local spots,
+// or an npm .cmd shim.
+//
+// Returns null if not present so callers can surface an install hint.
+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.resetCache = resetCache;
+exports.findGrokBinary = findGrokBinary;
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const win_1 = require("./win");
+const POSIX_CANDIDATES = [
+    path.join(os.homedir(), '.local', 'bin', 'grok'), // xAI installer default
+    path.join(os.homedir(), '.grok', 'bin', 'grok'),
+    '/usr/local/bin/grok',
+    '/opt/homebrew/bin/grok',
+];
+const WIN32_CANDIDATES = [
+    path.join(os.homedir(), '.local', 'bin', 'grok.exe'),
+    path.join(os.homedir(), '.grok', 'bin', 'grok.exe'),
+];
+/** Forget the cached lookup — call after an install so a fresh probe
+ *  can see a binary that was missing at daemon start. */
+function resetCache() { cached = undefined; }
+let cached;
+function findGrokBinary() {
+    if (cached !== undefined)
+        return cached;
+    cached = (0, win_1.findCliBinary)('grok', {
+        posixCandidates: POSIX_CANDIDATES,
+        win32Candidates: WIN32_CANDIDATES,
+    });
+    return cached;
+}

package/dist/grok-spawn.d.ts

@@ -0,0 +1,41 @@
+import type { RuntimeEvent, RuntimeEffortLevel } from './types';
+export interface GrokMcpServer {
+    slug: string;
+    command: string;
+    args?: string[] | null;
+    env?: Record<string, string> | null;
+}
+export interface GrokInput {
+    workingDirectory: string;
+    prompt: string;
+    model?: string;
+    /** Resume an existing session (mapped to `--resume <id>`). */
+    resumeSessionId?: string;
+    /** Autonomous runs can't answer approval prompts; headless always
+     *  auto-approves. This flag is accepted for parity but print mode is
+     *  always non-interactive. */
+    bypassPermissions?: boolean;
+    /** The entity's servers. Written to a per-session project config.toml so
+     *  grok exposes ONLY these (host Claude MCPs are masked via sandbox HOME). */
+    mcpServers?: GrokMcpServer[];
+    /** Studio-entity system prompt (identity + memory directive). Appended to
+     *  grok's own system prompt via `--rules`. */
+    appendSystemPrompt?: string;
+    /** Per-run reasoning effort → grok `--reasoning-effort`. Only low/medium/
+     *  high are forwarded (xhigh/max collapse to high) so we never emit an
+     *  unsupported value that would fail the spawn. */
+    effortLevel?: RuntimeEffortLevel;
+}
+export interface GrokHandle {
+    pid: number | undefined;
+    sessionId: string | null;
+    kill(): void;
+    onEvent(cb: (e: RuntimeEvent) => void): void;
+    /** Fires on every raw stdout/stderr chunk — byte-level liveness. Grok
+     *  emits NO events during tool execution (no per-tool stream), so parsed
+     *  events alone under-report life; any bytes at all prove the child is
+     *  still working and should hold off the hang watchdog. */
+    onActivity(cb: () => void): void;
+    done: Promise<number>;
+}
+export declare function spawnGrok(input: GrokInput): GrokHandle;