@nowcrew/daemon 0.5.26 → 0.5.27

package/dist/remote/codex-client.js

@@ -0,0 +1,408 @@
+import { randomUUID } from "node:crypto";
+import { WebSocket } from "ws";
+import { z } from "zod";
+const ThreadStatusSchema = z.discriminatedUnion("type", [
+    z.object({ type: z.literal("notLoaded") }).passthrough(),
+    z.object({ type: z.literal("idle") }).passthrough(),
+    z.object({ type: z.literal("systemError") }).passthrough(),
+    z.object({ type: z.literal("active"), activeFlags: z.array(z.unknown()).optional() }).passthrough(),
+]);
+const ThreadItemSchema = z.object({
+    type: z.string(),
+    id: z.string().optional(),
+}).passthrough();
+const TurnSchema = z.object({
+    id: z.string(),
+    status: z.string(),
+    items: z.array(ThreadItemSchema),
+    startedAt: z.number().nullable().optional(),
+    completedAt: z.number().nullable().optional(),
+}).passthrough();
+const ThreadSchema = z.object({
+    id: z.string().uuid(),
+    preview: z.string().default(""),
+    createdAt: z.number(),
+    updatedAt: z.number(),
+    recencyAt: z.number().nullable().optional(),
+    status: ThreadStatusSchema,
+    cwd: z.string(),
+    name: z.string().nullable().optional(),
+    turns: z.array(TurnSchema).default([]),
+}).passthrough();
+const ThreadListResponseSchema = z.object({
+    data: z.array(ThreadSchema),
+    nextCursor: z.string().nullable(),
+}).passthrough();
+const ThreadReadResponseSchema = z.object({ thread: ThreadSchema }).passthrough();
+const ThreadResumeResponseSchema = z.object({ thread: ThreadSchema }).passthrough();
+const ApprovalParamsSchema = z.object({
+    threadId: z.string().uuid(),
+    command: z.string().nullable().optional(),
+    reason: z.string().nullable().optional(),
+    grantRoot: z.string().nullable().optional(),
+}).passthrough();
+const QuestionParamsSchema = z.object({
+    threadId: z.string().uuid(),
+    questions: z.array(z.object({
+        id: z.string().min(1),
+        header: z.string(),
+        question: z.string(),
+        isSecret: z.boolean(),
+        options: z.array(z.object({
+            label: z.string(),
+            description: z.string(),
+        }).passthrough()).nullable(),
+    }).passthrough()).min(1).max(3),
+}).passthrough();
+function isoFromSeconds(value) {
+    return new Date((value ?? Date.now() / 1_000) * 1_000).toISOString();
+}
+function textInputs(content) {
+    if (!Array.isArray(content))
+        return "";
+    return content.flatMap((entry) => {
+        const value = entry;
+        if (value.type === "text" && typeof value.text === "string")
+            return [value.text];
+        if (value.type === "localImage" && typeof value.path === "string")
+            return [`[Image: ${value.path}]`];
+        return [];
+    }).join("\n").trim();
+}
+function itemToTimeline(raw, createdAt) {
+    const item = raw;
+    const id = typeof item.id === "string" ? `codex:${item.id}` : `codex:${randomUUID()}`;
+    if (item.type === "userMessage") {
+        const text = textInputs(item.content);
+        return text ? { id, kind: "message", role: "user", text, createdAt } : null;
+    }
+    if (item.type === "agentMessage" && typeof item.text === "string" && item.text.trim()) {
+        return { id, kind: "message", role: "assistant", text: item.text, createdAt };
+    }
+    if (item.type === "plan" && typeof item.text === "string") {
+        return { id, kind: "tool", name: "Plan", summary: item.text.slice(0, 12_000), status: "updated", createdAt };
+    }
+    if (item.type === "commandExecution" && typeof item.command === "string") {
+        const output = typeof item.aggregatedOutput === "string" ? `\n\n${item.aggregatedOutput}` : "";
+        return {
+            id,
+            kind: "tool",
+            name: "Command",
+            summary: `${item.command}${output}`.slice(0, 12_000),
+            status: typeof item.status === "string" ? item.status : "completed",
+            createdAt,
+        };
+    }
+    if (item.type === "fileChange") {
+        return {
+            id,
+            kind: "tool",
+            name: "File change",
+            summary: JSON.stringify(item.changes ?? []).slice(0, 12_000),
+            status: typeof item.status === "string" ? item.status : "completed",
+            createdAt,
+        };
+    }
+    if (item.type === "mcpToolCall" || item.type === "dynamicToolCall") {
+        const server = typeof item.server === "string" ? `${item.server}.` : "";
+        const tool = typeof item.tool === "string" ? item.tool : "tool";
+        return {
+            id,
+            kind: "tool",
+            name: `${server}${tool}`,
+            summary: JSON.stringify(item.arguments ?? {}).slice(0, 12_000),
+            status: typeof item.status === "string" ? item.status : "completed",
+            createdAt,
+        };
+    }
+    return null;
+}
+function threadSummary(thread) {
+    return {
+        id: thread.id,
+        runtime: "codex",
+        title: thread.name?.trim() || thread.preview.trim().slice(0, 240) || "Codex session",
+        cwd: thread.cwd,
+        updatedAt: isoFromSeconds(thread.recencyAt ?? thread.updatedAt),
+        controlState: "live",
+        busy: thread.status.type === "active",
+        source: "app_server",
+    };
+}
+function threadTimeline(thread) {
+    const items = [];
+    for (const turn of thread.turns) {
+        const createdAt = isoFromSeconds(turn.startedAt ?? turn.completedAt ?? thread.updatedAt);
+        for (const raw of turn.items) {
+            const mapped = itemToTimeline(raw, createdAt);
+            if (mapped)
+                items.push(mapped);
+        }
+    }
+    return items.length > 400 ? items.slice(items.length - 400) : items;
+}
+function ipcWebSocketUrl(socketPath) {
+    if (!socketPath.startsWith("/"))
+        throw new Error("Codex app-server socket path must be absolute");
+    if (socketPath.includes(":"))
+        throw new Error("Codex app-server socket path cannot contain ':'");
+    return `ws+unix://${socketPath}:/`;
+}
+export class CodexAppServerClient {
+    socket;
+    nextId = 1;
+    pending = new Map();
+    interactions = new Map();
+    listeners = new Set();
+    closedError = null;
+    constructor(socket) {
+        this.socket = socket;
+        socket.on("message", (raw) => this.receive(raw.toString()));
+        socket.once("close", () => this.fail(new Error("Codex app-server connection closed")));
+        socket.once("error", (error) => this.fail(error));
+    }
+    static async connect(socketPath, timeoutMs = 5_000) {
+        const socket = new WebSocket(ipcWebSocketUrl(socketPath), { perMessageDeflate: false });
+        await new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                socket.terminate();
+                reject(new Error(`Timed out connecting to Codex app-server at ${socketPath}`));
+            }, timeoutMs);
+            socket.once("open", () => {
+                clearTimeout(timer);
+                resolve();
+            });
+            socket.once("error", (error) => {
+                clearTimeout(timer);
+                reject(error);
+            });
+        });
+        const client = new CodexAppServerClient(socket);
+        await client.request("initialize", {
+            clientInfo: { name: "nowcrew_remote", title: "NowCrew Remote", version: "1.0.0" },
+            capabilities: { experimentalApi: true, requestAttestation: false },
+        });
+        client.notify("initialized");
+        return client;
+    }
+    async listSessions() {
+        const threads = [];
+        let cursor = null;
+        for (let page = 0; page < 2; page += 1) {
+            const response = ThreadListResponseSchema.parse(await this.request("thread/list", {
+                limit: 100,
+                ...(cursor === null ? {} : { cursor }),
+            }));
+            threads.push(...response.data);
+            cursor = response.nextCursor;
+            if (!cursor)
+                break;
+        }
+        return threads.map(threadSummary).sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+    }
+    async timeline(sessionId) {
+        try {
+            const response = ThreadReadResponseSchema.parse(await this.request("thread/read", {
+                threadId: sessionId,
+                includeTurns: true,
+            }));
+            return threadTimeline(response.thread);
+        }
+        catch (error) {
+            if (error instanceof Error && /not found|does not exist/i.test(error.message))
+                return null;
+            throw error;
+        }
+    }
+    async submit(sessionId, input) {
+        const resumed = ThreadResumeResponseSchema.parse(await this.request("thread/resume", { threadId: sessionId }));
+        const active = [...resumed.thread.turns].reverse().find((turn) => turn.status === "inProgress");
+        const params = {
+            threadId: sessionId,
+            clientUserMessageId: input.idempotencyKey,
+            input: [{ type: "text", text: input.text, text_elements: [] }],
+        };
+        if (active) {
+            await this.request("turn/steer", { ...params, expectedTurnId: active.id });
+        }
+        else {
+            await this.request("turn/start", params);
+        }
+        return { requestId: input.idempotencyKey };
+    }
+    resolveApproval(sessionId, requestId, decision) {
+        const pending = this.takeInteraction(sessionId, requestId, "approval");
+        if (!pending)
+            return false;
+        this.respond(pending.rpcId, { decision: decision === "allow" ? "accept" : "decline" });
+        return true;
+    }
+    resolveQuestion(sessionId, requestId, input) {
+        const pending = this.takeInteraction(sessionId, requestId, "question");
+        if (!pending)
+            return false;
+        this.respond(pending.rpcId, {
+            answers: Object.fromEntries(Object.entries(input.answers).map(([id, answers]) => [id, { answers }])),
+        });
+        return true;
+    }
+    onEvent(listener) {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+    }
+    async close() {
+        if (this.socket.readyState === WebSocket.CLOSED)
+            return;
+        await new Promise((resolve) => {
+            const timer = setTimeout(() => {
+                this.socket.terminate();
+                resolve();
+            }, 1_000);
+            this.socket.once("close", () => {
+                clearTimeout(timer);
+                resolve();
+            });
+            this.socket.close(1000, "NowCrew gateway stopping");
+        });
+    }
+    request(method, params, timeoutMs = 30_000) {
+        if (this.closedError)
+            return Promise.reject(this.closedError);
+        const id = this.nextId++;
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(id);
+                reject(new Error(`Codex app-server ${method} timed out`));
+            }, timeoutMs);
+            this.pending.set(id, { resolve, reject, timer });
+            this.send({ id, method, params });
+        });
+    }
+    notify(method, params) {
+        this.send({ method, ...(params === undefined ? {} : { params }) });
+    }
+    respond(id, result) {
+        this.send({ id, result });
+    }
+    send(value) {
+        if (this.socket.readyState !== WebSocket.OPEN)
+            throw this.closedError ?? new Error("Codex app-server is not open");
+        this.socket.send(JSON.stringify(value));
+    }
+    receive(raw) {
+        let message;
+        try {
+            message = JSON.parse(raw);
+        }
+        catch {
+            return;
+        }
+        if (message.id !== undefined && message.method !== undefined) {
+            this.receiveServerRequest(message.id, message.method, message.params);
+            return;
+        }
+        if (message.id !== undefined) {
+            const pending = this.pending.get(message.id);
+            if (!pending)
+                return;
+            this.pending.delete(message.id);
+            clearTimeout(pending.timer);
+            if (message.error)
+                pending.reject(new Error(`Codex app-server RPC failed: ${message.error.message ?? "unknown error"}`));
+            else
+                pending.resolve(message.result);
+            return;
+        }
+        if (message.method)
+            this.receiveNotification(message.method, message.params);
+    }
+    receiveServerRequest(id, method, params) {
+        if (method === "item/commandExecution/requestApproval" || method === "item/fileChange/requestApproval") {
+            const parsed = ApprovalParamsSchema.safeParse(params);
+            if (!parsed.success) {
+                this.respond(id, { decision: "decline" });
+                return;
+            }
+            const requestId = randomUUID();
+            this.interactions.set(requestId, { rpcId: id, sessionId: parsed.data.threadId, type: "approval" });
+            const tool = method.includes("commandExecution") ? "Command" : "File change";
+            const preview = parsed.data.command ?? parsed.data.grantRoot ?? parsed.data.reason ?? tool;
+            this.emit({
+                type: "timeline.appended",
+                sessionId: parsed.data.threadId,
+                item: { id: `codex-approval:${requestId}`, kind: "approval", requestId, tool, preview, createdAt: new Date().toISOString() },
+            });
+            return;
+        }
+        if (method === "item/tool/requestUserInput") {
+            const parsed = QuestionParamsSchema.safeParse(params);
+            if (!parsed.success) {
+                this.respond(id, { answers: {} });
+                return;
+            }
+            const requestId = randomUUID();
+            this.interactions.set(requestId, { rpcId: id, sessionId: parsed.data.threadId, type: "question" });
+            this.emit({
+                type: "timeline.appended",
+                sessionId: parsed.data.threadId,
+                item: {
+                    id: `codex-question:${requestId}`,
+                    kind: "question",
+                    requestId,
+                    questions: parsed.data.questions.map((question) => ({
+                        id: question.id,
+                        header: question.header,
+                        question: question.question,
+                        isSecret: question.isSecret,
+                        options: question.options,
+                    })),
+                    createdAt: new Date().toISOString(),
+                },
+            });
+            return;
+        }
+        this.send({ id, error: { code: -32001, message: `NowCrew does not support ${method}` } });
+    }
+    receiveNotification(method, params) {
+        if (["thread/started", "thread/status/changed", "thread/name/updated", "turn/started", "turn/completed"].includes(method)) {
+            this.emit({ type: "sessions.changed" });
+        }
+        if (method !== "item/completed")
+            return;
+        const parsed = z.object({
+            threadId: z.string().uuid(),
+            item: ThreadItemSchema,
+            completedAtMs: z.number().optional(),
+        }).passthrough().safeParse(params);
+        if (!parsed.success)
+            return;
+        if (parsed.data.item.type === "userMessage")
+            return;
+        const item = itemToTimeline(parsed.data.item, new Date(parsed.data.completedAtMs ?? Date.now()).toISOString());
+        if (item)
+            this.emit({ type: "timeline.appended", sessionId: parsed.data.threadId, item });
+    }
+    takeInteraction(sessionId, requestId, type) {
+        const pending = this.interactions.get(requestId);
+        if (!pending || pending.sessionId !== sessionId || pending.type !== type)
+            return null;
+        this.interactions.delete(requestId);
+        return pending;
+    }
+    emit(event) {
+        for (const listener of this.listeners)
+            listener(event);
+    }
+    fail(error) {
+        if (this.closedError)
+            return;
+        this.closedError = error;
+        for (const pending of this.pending.values()) {
+            clearTimeout(pending.timer);
+            pending.reject(error);
+        }
+        this.pending.clear();
+        this.interactions.clear();
+        this.emit({ type: "sessions.changed" });
+    }
+}

package/dist/remote/codex-runtime.js

@@ -0,0 +1,77 @@
+import { once } from "node:events";
+import { lstat, mkdir, unlink } from "node:fs/promises";
+import { dirname } from "node:path";
+import spawn from "cross-spawn";
+import { CodexAppServerClient } from "./codex-client.js";
+async function connect(socketPath, timeoutMs) {
+    try {
+        return await CodexAppServerClient.connect(socketPath, timeoutMs);
+    }
+    catch {
+        return null;
+    }
+}
+async function removeStaleSocket(socketPath) {
+    try {
+        const info = await lstat(socketPath);
+        if (!info.isSocket())
+            throw new Error(`Refusing to replace non-socket path: ${socketPath}`);
+        await unlink(socketPath);
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+    }
+}
+export async function startCodexRuntime(socketPath, bin = process.env.NOWCREW_CODEX_BIN ?? "codex") {
+    const existing = await connect(socketPath, 500);
+    if (existing) {
+        return { adapter: existing, socketPath, close: () => existing.close() };
+    }
+    await mkdir(dirname(socketPath), { recursive: true, mode: 0o700 });
+    await removeStaleSocket(socketPath);
+    const child = spawn(bin, ["app-server", "--listen", `unix://${socketPath}`], {
+        env: process.env,
+        stdio: ["ignore", "ignore", "pipe"],
+    });
+    let stderr = "";
+    child.stderr?.on("data", (chunk) => {
+        stderr = `${stderr}${String(chunk)}`.slice(-4_000);
+    });
+    let adapter = null;
+    for (let attempt = 0; attempt < 50; attempt += 1) {
+        if (child.exitCode !== null || child.signalCode !== null)
+            break;
+        await new Promise((resolve) => setTimeout(resolve, 100));
+        adapter = await connect(socketPath, 500);
+        if (adapter)
+            break;
+    }
+    if (!adapter) {
+        if (child.exitCode === null && child.signalCode === null)
+            child.kill("SIGTERM");
+        throw new Error(`Codex app-server did not start at ${socketPath}${stderr ? `: ${stderr.trim()}` : ""}`);
+    }
+    return {
+        adapter,
+        socketPath,
+        async close() {
+            await adapter.close();
+            if (child.exitCode !== null || child.signalCode !== null)
+                return;
+            const closed = once(child, "close").then(() => undefined);
+            child.kill("SIGTERM");
+            let timer;
+            const stopped = await Promise.race([
+                closed.then(() => true),
+                new Promise((resolve) => { timer = setTimeout(() => resolve(false), 1_000); }),
+            ]);
+            if (timer)
+                clearTimeout(timer);
+            if (!stopped && child.exitCode === null && child.signalCode === null) {
+                child.kill("SIGKILL");
+                await closed;
+            }
+        },
+    };
+}

package/dist/remote/config.js

@@ -0,0 +1,83 @@
+import { randomBytes } from "node:crypto";
+import { mkdir, open, readFile, rename } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { z } from "zod";
+const RemoteConfigFileSchema = z.object({
+    version: z.literal(1),
+    host: z.string().min(1),
+    port: z.number().int().min(1).max(65_535),
+    allowedOrigins: z.array(z.string().url()).max(16),
+}).strict();
+export function remotePaths(root = process.env.NOWCREW_REMOTE_HOME ?? join(homedir(), ".nowcrew", "remote")) {
+    return {
+        root,
+        config: join(root, "config.json"),
+        token: join(root, "token"),
+        lock: join(root, "gateway.lock.json"),
+        codexSocket: join(root, "codex", "app-server.sock"),
+    };
+}
+async function readOptional(path) {
+    try {
+        return await readFile(path, "utf8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return null;
+        throw error;
+    }
+}
+async function writeOwnerOnly(path, contents) {
+    await mkdir(dirname(path), { recursive: true, mode: 0o700 });
+    const tmp = `${path}.${process.pid}.${randomBytes(6).toString("hex")}.tmp`;
+    const file = await open(tmp, "wx", 0o600);
+    try {
+        await file.writeFile(contents, "utf8");
+        await file.sync();
+    }
+    finally {
+        await file.close();
+    }
+    await rename(tmp, path);
+}
+export async function loadOrCreateRemoteConfig(overrides = {}) {
+    const paths = remotePaths(overrides.root);
+    await mkdir(paths.root, { recursive: true, mode: 0o700 });
+    const existingConfig = await readOptional(paths.config);
+    const parsed = existingConfig === null
+        ? { version: 1, host: "127.0.0.1", port: 4317, allowedOrigins: [] }
+        : RemoteConfigFileSchema.parse(JSON.parse(existingConfig));
+    const fileConfig = RemoteConfigFileSchema.parse({
+        ...parsed,
+        ...(overrides.host === undefined ? {} : { host: overrides.host }),
+        ...(overrides.port === undefined ? {} : { port: overrides.port }),
+    });
+    if (existingConfig === null || fileConfig.host !== parsed.host || fileConfig.port !== parsed.port) {
+        await writeOwnerOnly(paths.config, `${JSON.stringify(fileConfig, null, 2)}\n`);
+    }
+    const existingToken = (await readOptional(paths.token))?.trim();
+    const token = existingToken && /^[A-Za-z0-9_-]{43}$/.test(existingToken)
+        ? existingToken
+        : randomBytes(32).toString("base64url");
+    if (token !== existingToken)
+        await writeOwnerOnly(paths.token, `${token}\n`);
+    return { ...fileConfig, token, paths };
+}
+export async function updateRemoteBinding(config, input) {
+    const next = RemoteConfigFileSchema.parse({
+        version: 1,
+        host: input.host,
+        port: input.port,
+        allowedOrigins: input.allowedOrigins ?? config.allowedOrigins,
+    });
+    await writeOwnerOnly(config.paths.config, `${JSON.stringify(next, null, 2)}\n`);
+    return { ...next, token: config.token, paths: config.paths };
+}
+export async function writeRemoteLock(path, value) {
+    await writeOwnerOnly(path, `${JSON.stringify(value, null, 2)}\n`);
+}
+// Exported for tests that verify atomic replacement without duplicating filesystem logic.
+export async function writeRemoteConfigForTest(path, contents) {
+    await writeOwnerOnly(path, contents);
+}