@nowcrew/daemon 0.6.6 → 0.6.7

package/dist/remote/runtime-probe.js

@@ -1,182 +0,0 @@
-import spawn from "cross-spawn";
-const PROBE_TIMEOUT_MS = 3_000;
-const PROBE_OUTPUT_BYTES = 128 * 1024;
-function appendBounded(current, chunk, remaining) {
-    if (remaining <= 0)
-        return { text: current, bytes: 0, exceeded: chunk.length > 0 };
-    const kept = chunk.subarray(0, remaining);
-    return {
-        text: current + kept.toString("utf8"),
-        bytes: kept.length,
-        exceeded: chunk.length > kept.length,
-    };
-}
-export const systemRuntimeProbeRunner = (bin, args) => new Promise((resolve) => {
-    let stdout = "";
-    let stderr = "";
-    let capturedBytes = 0;
-    let failure;
-    let settled = false;
-    let forceTimer;
-    let child;
-    const finish = (exitCode) => {
-        if (settled)
-            return;
-        settled = true;
-        clearTimeout(timeout);
-        if (forceTimer)
-            clearTimeout(forceTimer);
-        resolve({
-            exitCode,
-            stdout,
-            stderr,
-            ...(failure === undefined ? {} : { failure }),
-        });
-    };
-    const stop = (nextFailure) => {
-        if (failure !== undefined)
-            return;
-        failure = nextFailure;
-        if (child.exitCode !== null || child.signalCode !== null)
-            return;
-        child.kill("SIGTERM");
-        forceTimer = setTimeout(() => {
-            if (child.exitCode === null && child.signalCode === null)
-                child.kill("SIGKILL");
-        }, 250);
-    };
-    const capture = (stream, raw) => {
-        const chunk = Buffer.isBuffer(raw) ? raw : Buffer.from(raw);
-        const appended = appendBounded(stream === "stdout" ? stdout : stderr, chunk, PROBE_OUTPUT_BYTES - capturedBytes);
-        capturedBytes += appended.bytes;
-        if (stream === "stdout")
-            stdout = appended.text;
-        else
-            stderr = appended.text;
-        if (appended.exceeded || capturedBytes >= PROBE_OUTPUT_BYTES)
-            stop("output_limit");
-    };
-    try {
-        child = spawn(bin, [...args], { env: process.env, stdio: ["ignore", "pipe", "pipe"] });
-    }
-    catch {
-        resolve({ exitCode: 127, stdout: "", stderr: "", failure: "unavailable" });
-        return;
-    }
-    const timeout = setTimeout(() => stop("timeout"), PROBE_TIMEOUT_MS);
-    child.stdout?.on("data", (chunk) => capture("stdout", chunk));
-    child.stderr?.on("data", (chunk) => capture("stderr", chunk));
-    child.once("error", () => {
-        failure = "unavailable";
-        finish(127);
-    });
-    child.once("close", (code, signal) => finish(code ?? (signal ? 1 : 0)));
-});
-function parseVersion(output) {
-    const match = output.match(/\b(\d+)\.(\d+)\.(\d+)(-[0-9A-Za-z.-]+)?\b/);
-    if (!match)
-        return null;
-    return {
-        major: Number(match[1]),
-        minor: Number(match[2]),
-        patch: Number(match[3]),
-        text: `${match[1]}.${match[2]}.${match[3]}${match[4] ?? ""}`,
-        prerelease: match[4] !== undefined,
-    };
-}
-function atLeast(value, minimum) {
-    const actual = [value.major, value.minor, value.patch];
-    for (let index = 0; index < actual.length; index += 1) {
-        if (actual[index] > minimum[index])
-            return true;
-        if (actual[index] < minimum[index])
-            return false;
-    }
-    return true;
-}
-function failedCommand(runtime, result, phase) {
-    const name = runtime === "claude" ? "Claude Code" : "Codex";
-    if (!result)
-        return { runtime, state: "unsupported", reason: `${name} ${phase} probe did not run` };
-    if (result.failure === "unavailable") {
-        return { runtime, state: "offline", reason: `${name} executable is not available` };
-    }
-    if (result.failure === "timeout") {
-        return { runtime, state: "offline", reason: `${name} ${phase} probe timed out` };
-    }
-    if (result.failure === "output_limit") {
-        return { runtime, state: "unsupported", reason: `${name} ${phase} output exceeded the safety limit` };
-    }
-    if (result.exitCode !== 0) {
-        return {
-            runtime,
-            state: phase === "version" ? "offline" : "unsupported",
-            reason: `${name} ${phase} probe exited with code ${result.exitCode}`,
-        };
-    }
-    return null;
-}
-function missingCapabilities(output, capabilities) {
-    return capabilities.filter((capability) => !output.includes(capability));
-}
-export function evaluateRuntimeProbe(runtime, evidence) {
-    const versionFailure = failedCommand(runtime, evidence.version, "version");
-    if (versionFailure)
-        return versionFailure;
-    const version = parseVersion(`${evidence.version.stdout}\n${evidence.version.stderr}`);
-    const name = runtime === "claude" ? "Claude Code" : "Codex";
-    if (!version)
-        return { runtime, state: "unsupported", reason: `${name} returned an unrecognized version` };
-    const minimum = runtime === "claude" ? [2, 1, 170] : [0, 145, 0];
-    const expectedMajor = runtime === "claude" ? 2 : 0;
-    if (version.prerelease || version.major !== expectedMajor || !atLeast(version, minimum)) {
-        return {
-            runtime,
-            state: "unsupported",
-            version: version.text,
-            reason: `${name} ${version.text} is outside the supported range >=${minimum.join(".")} and <${expectedMajor + 1}.0.0`,
-        };
-    }
-    const helpFailure = failedCommand(runtime, evidence.help, "capability");
-    if (helpFailure)
-        return { ...helpFailure, version: version.text };
-    const help = `${evidence.help.stdout}\n${evidence.help.stderr}`;
-    const required = runtime === "claude"
-        ? ["--input-format", "stream-json", "--output-format", "--replay-user-messages", "--session-id", "--resume"]
-        : ["app-server", "--remote", "unix://"];
-    const missing = missingCapabilities(help, required);
-    if (runtime === "codex") {
-        const appServerFailure = failedCommand(runtime, evidence.appServerHelp, "app-server capability");
-        if (appServerFailure)
-            return { ...appServerFailure, version: version.text };
-        const appServerHelp = `${evidence.appServerHelp.stdout}\n${evidence.appServerHelp.stderr}`;
-        missing.push(...missingCapabilities(appServerHelp, ["--listen", "unix://"]));
-    }
-    const uniqueMissing = [...new Set(missing)];
-    if (uniqueMissing.length > 0) {
-        return {
-            runtime,
-            state: "unsupported",
-            version: version.text,
-            reason: `${name} ${version.text} is missing required capabilities: ${uniqueMissing.join(", ")}`,
-        };
-    }
-    return { runtime, state: "supported", version: version.text, reason: `${name} ${version.text} is supported` };
-}
-export async function probeRuntime(runtime, runner = systemRuntimeProbeRunner) {
-    const bin = runtime === "claude"
-        ? process.env.NOWCREW_CLAUDE_BIN ?? "claude"
-        : process.env.NOWCREW_CODEX_BIN ?? "codex";
-    const version = await runner(bin, ["--version"]);
-    if (failedCommand(runtime, version, "version"))
-        return evaluateRuntimeProbe(runtime, { version });
-    const help = await runner(bin, ["--help"]);
-    if (failedCommand(runtime, help, "capability"))
-        return evaluateRuntimeProbe(runtime, { version, help });
-    const appServerHelp = runtime === "codex" ? await runner(bin, ["app-server", "--help"]) : undefined;
-    return evaluateRuntimeProbe(runtime, {
-        version,
-        help,
-        ...(appServerHelp === undefined ? {} : { appServerHelp }),
-    });
-}

package/dist/remote/session-discovery.js

@@ -1,249 +0,0 @@
-import { open, readdir, stat } from "node:fs/promises";
-import { basename, join } from "node:path";
-const SESSION_ID = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
-const DEFAULT_HISTORY_BYTES = 4 * 1024 * 1024;
-const DEFAULT_TIMELINE_ITEMS = 400;
-async function collectJsonl(root, depth, cap) {
-    const result = [];
-    const walk = async (dir, remaining) => {
-        if (remaining < 0 || result.length >= cap)
-            return;
-        let entries;
-        try {
-            entries = await readdir(dir, { withFileTypes: true });
-        }
-        catch (error) {
-            if (error.code === "ENOENT")
-                return;
-            throw error;
-        }
-        for (const entry of entries) {
-            if (result.length >= cap)
-                return;
-            const path = join(dir, entry.name);
-            if (entry.isDirectory()) {
-                await walk(path, remaining - 1);
-            }
-            else if (entry.isFile() && entry.name.endsWith(".jsonl")) {
-                const name = basename(entry.name, ".jsonl");
-                const id = name.startsWith("rollout-") ? name.slice(name.lastIndexOf("-") + 1) : name;
-                const match = entry.name.match(/([0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12})\.jsonl$/i);
-                const sessionId = match?.[1] ?? id;
-                if (!SESSION_ID.test(sessionId))
-                    continue;
-                const info = await stat(path);
-                result.push({ path, id: sessionId, mtimeMs: info.mtimeMs, updatedAt: info.mtime.toISOString() });
-            }
-        }
-    };
-    await walk(root, depth);
-    return result.sort((a, b) => b.mtimeMs - a.mtimeMs);
-}
-async function readTailLines(path, maxBytes) {
-    const file = await open(path, "r");
-    try {
-        const info = await file.stat();
-        const length = Math.min(info.size, maxBytes);
-        if (length === 0)
-            return [];
-        const buffer = Buffer.allocUnsafe(length);
-        await file.read(buffer, 0, length, info.size - length);
-        const text = buffer.toString("utf8");
-        const lines = text.split("\n");
-        if (info.size > length)
-            lines.shift();
-        return lines.filter(Boolean);
-    }
-    finally {
-        await file.close();
-    }
-}
-function object(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value)
-        ? value
-        : null;
-}
-function string(value) {
-    return typeof value === "string" && value.trim() ? value.trim() : null;
-}
-function textFromContent(value) {
-    if (typeof value === "string")
-        return string(value);
-    if (!Array.isArray(value))
-        return null;
-    const parts = [];
-    for (const raw of value) {
-        const block = object(raw);
-        if (!block)
-            continue;
-        if (["text", "input_text", "output_text"].includes(String(block.type))) {
-            const text = string(block.text);
-            if (text)
-                parts.push(text);
-        }
-    }
-    return parts.length ? parts.join("\n") : null;
-}
-function cleanChannelText(value) {
-    return value
-        .replace(/^<channel\b[^>]*>\s*/i, "")
-        .replace(/\s*<\/channel>$/i, "")
-        .trim();
-}
-function parseLine(line) {
-    try {
-        return object(JSON.parse(line));
-    }
-    catch {
-        return null;
-    }
-}
-function claudeItems(lines, fallbackAt) {
-    let cwd = "";
-    let title = null;
-    const items = [];
-    for (let index = 0; index < lines.length; index += 1) {
-        const row = parseLine(lines[index]);
-        if (!row)
-            continue;
-        cwd = string(row.cwd) ?? cwd;
-        const message = object(row.message);
-        const role = row.type === "user" || row.type === "assistant" ? row.type : null;
-        const text = message ? textFromContent(message.content) : null;
-        const createdAt = string(row.timestamp) ?? fallbackAt;
-        const id = string(row.uuid) ?? `claude:${index}`;
-        if (role && text) {
-            const cleaned = cleanChannelText(text);
-            if (!cleaned)
-                continue;
-            if (role === "user")
-                title = cleaned.slice(0, 120);
-            items.push({ id, kind: "message", role, text: cleaned, createdAt });
-        }
-        if (role !== "assistant" || !message || !Array.isArray(message.content))
-            continue;
-        for (let blockIndex = 0; blockIndex < message.content.length; blockIndex += 1) {
-            const block = object(message.content[blockIndex]);
-            if (!block || block.type !== "tool_use")
-                continue;
-            const name = string(block.name) ?? "tool";
-            const summary = JSON.stringify(block.input ?? {}).slice(0, 12_000);
-            items.push({
-                id: `${id}:tool:${blockIndex}`,
-                kind: "tool",
-                name,
-                summary,
-                status: "requested",
-                createdAt,
-            });
-        }
-    }
-    return { cwd, title, items };
-}
-function codexItems(lines, fallbackAt) {
-    let cwd = "";
-    let title = null;
-    const items = [];
-    for (let index = 0; index < lines.length; index += 1) {
-        const row = parseLine(lines[index]);
-        if (!row)
-            continue;
-        const payload = object(row.payload);
-        if (!payload)
-            continue;
-        if (row.type === "session_meta")
-            cwd = string(payload.cwd) ?? cwd;
-        if (row.type !== "response_item" || payload.type !== "message")
-            continue;
-        const role = payload.role === "user" || payload.role === "assistant" ? payload.role : null;
-        const text = textFromContent(payload.content);
-        if (!role || !text)
-            continue;
-        const createdAt = string(row.timestamp) ?? fallbackAt;
-        const id = `codex:${index}:${createdAt}`;
-        if (role === "user")
-            title = text.slice(0, 120);
-        items.push({ id, kind: "message", role, text, createdAt });
-    }
-    return { cwd, title, items };
-}
-function capItems(items, max) {
-    return items.length <= max ? [...items] : items.slice(items.length - max);
-}
-export class RemoteSessionDiscovery {
-    options;
-    files = new Map();
-    constructor(options) {
-        this.options = options;
-    }
-    async list() {
-        const maxSessions = this.options.maxSessions ?? 100;
-        const historyBytes = this.options.maxHistoryBytes ?? DEFAULT_HISTORY_BYTES;
-        const [claude, codex] = await Promise.all([
-            collectJsonl(this.options.claudeProjectsRoot, 2, maxSessions * 4),
-            collectJsonl(this.options.codexSessionsRoot, 4, maxSessions * 4),
-        ]);
-        this.files.clear();
-        const summaries = [];
-        for (const [runtime, candidates] of [["claude", claude], ["codex", codex]]) {
-            for (const candidate of candidates.slice(0, maxSessions)) {
-                const key = `${runtime}:${candidate.id}`;
-                if (this.files.has(key))
-                    continue;
-                this.files.set(key, candidate);
-                const lines = await readTailLines(candidate.path, historyBytes);
-                const parsed = runtime === "claude"
-                    ? claudeItems(lines, candidate.updatedAt)
-                    : codexItems(lines, candidate.updatedAt);
-                const active = runtime === "claude"
-                    ? this.options.activeClaude?.get(candidate.id)
-                    : this.options.activeCodex?.get(candidate.id);
-                summaries.push({
-                    id: candidate.id,
-                    runtime,
-                    title: active?.title ?? parsed.title ?? `${runtime === "claude" ? "Claude" : "Codex"} session`,
-                    cwd: active?.cwd ?? parsed.cwd,
-                    updatedAt: active?.updatedAt ?? candidate.updatedAt,
-                    controlState: this.options.runtimeStates?.[runtime] ?? (active ? "live" : "read_only"),
-                    busy: active?.busy ?? false,
-                    source: active ? (runtime === "claude" ? "channel" : "app_server") : "history",
-                });
-            }
-        }
-        for (const [runtime, activeSessions] of [["claude", this.options.activeClaude], ["codex", this.options.activeCodex]]) {
-            for (const [id, active] of activeSessions ?? []) {
-                if (summaries.some((session) => session.runtime === runtime && session.id === id))
-                    continue;
-                summaries.push({
-                    id,
-                    runtime,
-                    title: active.title ?? `${runtime === "claude" ? "Claude" : "Codex"} session`,
-                    cwd: active.cwd,
-                    updatedAt: active.updatedAt ?? new Date().toISOString(),
-                    controlState: this.options.runtimeStates?.[runtime] ?? "live",
-                    busy: active.busy,
-                    source: runtime === "claude" ? "channel" : "app_server",
-                });
-            }
-        }
-        return summaries.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt)).slice(0, maxSessions);
-    }
-    async timeline(runtime, sessionId) {
-        if (!SESSION_ID.test(sessionId))
-            return null;
-        let candidate = this.files.get(`${runtime}:${sessionId}`);
-        if (!candidate) {
-            await this.list();
-            candidate = this.files.get(`${runtime}:${sessionId}`);
-        }
-        if (!candidate) {
-            const active = runtime === "claude" ? this.options.activeClaude?.has(sessionId) : this.options.activeCodex?.has(sessionId);
-            return active ? [] : null;
-        }
-        const lines = await readTailLines(candidate.path, this.options.maxHistoryBytes ?? DEFAULT_HISTORY_BYTES);
-        const parsed = runtime === "claude"
-            ? claudeItems(lines, candidate.updatedAt)
-            : codexItems(lines, candidate.updatedAt);
-        return capItems(parsed.items, this.options.maxTimelineItems ?? DEFAULT_TIMELINE_ITEMS);
-    }
-}

package/dist/remote/wrapper.js

@@ -1,40 +0,0 @@
-import { randomUUID } from "node:crypto";
-const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
-function optionValue(args, long, short) {
-    for (let index = 0; index < args.length; index += 1) {
-        const value = args[index];
-        if (value.startsWith(`${long}=`))
-            return value.slice(long.length + 1);
-        if (value === long || (short && value === short)) {
-            const next = args[index + 1];
-            return next && !next.startsWith("-") ? next : null;
-        }
-    }
-    return null;
-}
-export function resolveClaudeWrapperSession(args, createId = randomUUID) {
-    if (args.includes("--continue") || args.includes("-c")) {
-        throw new Error("NowCrew remote requires an explicit session ID; use --resume <session-id> instead of --continue");
-    }
-    if (args.includes("--fork-session")) {
-        throw new Error("NowCrew remote cannot identify a fork chosen inside Claude; start a new session or resume without --fork-session");
-    }
-    const sessionId = optionValue(args, "--session-id") ?? optionValue(args, "--resume", "-r") ?? createId();
-    if (!UUID.test(sessionId)) {
-        throw new Error("Claude remote sessions require a UUID in --session-id or --resume");
-    }
-    const hasSessionSelector = args.some((value) => value === "--session-id" || value.startsWith("--session-id=")
-        || value === "--resume" || value.startsWith("--resume=") || value === "-r");
-    return {
-        sessionId,
-        args: hasSessionSelector ? [...args] : ["--session-id", sessionId, ...args],
-    };
-}
-export function buildCodexWrappedInvocation(userArgs, socketPath = "", bin = process.env.NOWCREW_CODEX_BIN ?? "codex") {
-    const hasRemote = userArgs.some((value) => value === "--remote" || value.startsWith("--remote="));
-    return {
-        bin,
-        args: hasRemote ? [...userArgs] : ["--remote", socketPath ? `unix://${socketPath}` : "unix://", ...userArgs],
-        env: process.env,
-    };
-}