@span-io/agent-link 0.1.1 → 0.1.3

package/README.md

@@ -72,7 +72,12 @@ Configuration is stored in `~/.config/remote-agent/client.json`.
 **Environment Variables:**
 *   `CODEX_BIN`, `GEMINI_BIN`, `CLAUDE_BIN`: Override the path to specific agent binaries.
 *   `CODEX_CWD`: Set the working directory for the agent (defaults to the directory where you ran the client).
+*   `AGENT_LINK_PROMPT_CHAR_LIMIT` (or `CODEX_PROMPT_CHAR_LIMIT`): Hard cap for prompt length in characters (default `200000`).
+*   `AGENT_LINK_PROMPT_CHAR_THRESHOLD` (or `CODEX_PROMPT_CHAR_THRESHOLD`): Length at which compaction kicks in (default `90%` of limit).
+*   `AGENT_LINK_PROMPT_CHAR_TARGET` (or `CODEX_PROMPT_CHAR_TARGET`): Target length after compaction (default `85%` of limit).
+*   `AGENT_LINK_PROMPT_COMPACT` (or `CODEX_PROMPT_COMPACT`): `auto`, `summary`, `truncate`, or `off` (default `auto`).
+*   `AGENT_LINK_PROMPT_SUMMARY_LINES` (or `CODEX_PROMPT_SUMMARY_LINES`): Max lines to include in heuristic summary (default `20`).
 
 ## License
 
-MIT
+MIT

package/dist/index.js

@@ -5,6 +5,7 @@ import { loadConfig, saveConfig } from "./config.js";
 import { findAgentsOnPath, resolveAgentBinary } from "./agent.js";
 import { spawnAgentProcess as spawnAgentProcessAdvanced } from "./process-runner.js";
 import { LogBuffer } from "./log-buffer.js";
+import { compactPrompt, resolvePromptCompactionPolicy } from "./prompt-compact.js";
 import { NoopTransport, WebSocketTransport } from "./transport.js";
 const args = parseArgs(process.argv.slice(2));
 if (args.list) {
@@ -43,6 +44,7 @@ if (args.pairingCode) {
 const logBuffer = new LogBuffer();
 // Update map to hold SpawnedProcess which includes the child
 const activeAgents = new Map();
+const promptPolicy = resolvePromptCompactionPolicy();
 let transport;
 try {
     transport = await createTransport({
@@ -67,7 +69,11 @@ function handleControl(message) {
             let agentProc = activeAgents.get(agentId);
             if (agentProc) {
                 if (payload?.prompt && agentProc.child.stdin) {
-                    agentProc.child.stdin.write(`${payload.prompt}\n`);
+                    const normalized = compactPrompt(payload.prompt, promptPolicy);
+                    if (normalized.action !== "none") {
+                        console.warn(`Prompt ${normalized.action} (${normalized.reason ?? "threshold"}): ${normalized.originalLength} -> ${normalized.finalLength} chars.`);
+                    }
+                    agentProc.child.stdin.write(`${normalized.prompt}\n`);
                 }
                 return;
             }
@@ -110,13 +116,18 @@ function handleControl(message) {
                 return;
             }
             const optionsArgs = [...(payload?.args || args.agentArgs)];
+            const rawPrompt = payload?.prompt || "";
+            const normalized = compactPrompt(rawPrompt, promptPolicy);
+            if (normalized.action !== "none") {
+                console.warn(`Prompt ${normalized.action} (${normalized.reason ?? "threshold"}): ${normalized.originalLength} -> ${normalized.finalLength} chars.`);
+            }
             const proc = spawnAgentProcessAdvanced({
                 agent: {
                     id: agentId,
                     name: agentCandidate.name,
                     model: targetModel || "codex-cli"
                 },
-                prompt: payload?.prompt || "",
+                prompt: normalized.prompt,
                 optionsArgs,
                 executablePath: agentCandidate.path
             });
@@ -139,7 +150,11 @@ function handleControl(message) {
             const proc = activeAgents.get(agentId);
             const data = message.data || payload?.prompt;
             if (proc && data && proc.child.stdin) {
-                proc.child.stdin.write(data.endsWith("\n") ? data : `${data}\n`);
+                const normalized = compactPrompt(data, promptPolicy);
+                if (normalized.action !== "none") {
+                    console.warn(`Prompt ${normalized.action} (${normalized.reason ?? "threshold"}): ${normalized.originalLength} -> ${normalized.finalLength} chars.`);
+                }
+                proc.child.stdin.write(normalized.prompt.endsWith("\n") ? normalized.prompt : `${normalized.prompt}\n`);
             }
             break;
         }

package/dist/process-runner.js

@@ -1,3 +1,4 @@
+import { mkdirSync } from "fs";
 import { spawn } from "child_process";
 const DEFAULT_CODEX_ARGS = "exec --skip-git-repo-check";
 const DEFAULT_GEMINI_ARGS = "";
@@ -12,6 +13,50 @@ function shellQuote(value) {
     // Simple single-quote wrapping for display purposes
     return `'${value.replace(/'/g, `'"'"'`)}'`;
 }
+function collectDirectoriesFromArgs(args) {
+    const directories = [];
+    for (let i = 0; i < args.length; i += 1) {
+        const arg = args[i];
+        const next = args[i + 1];
+        if ((arg === "--cd" || arg === "-C" || arg === "--add-dir" || arg === "--include-directories") && typeof next === "string") {
+            directories.push(next);
+            i += 1;
+            continue;
+        }
+        if (arg.startsWith("--cd=")) {
+            directories.push(arg.slice("--cd=".length));
+            continue;
+        }
+        if (arg.startsWith("--add-dir=")) {
+            directories.push(arg.slice("--add-dir=".length));
+            continue;
+        }
+        if (arg.startsWith("--include-directories=")) {
+            const raw = arg.slice("--include-directories=".length);
+            raw
+                .split(",")
+                .map((entry) => entry.trim())
+                .filter(Boolean)
+                .forEach((entry) => directories.push(entry));
+            continue;
+        }
+    }
+    return directories;
+}
+function ensureDirectoriesExist(rawDirs) {
+    const deduped = new Set(rawDirs
+        .map((entry) => entry.trim())
+        .filter((entry) => entry.length > 0));
+    for (const dir of deduped) {
+        try {
+            mkdirSync(dir, { recursive: true });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            throw new Error(`Failed to create working directory '${dir}': ${message}`);
+        }
+    }
+}
 export function buildCommand({ agent, prompt, optionsArgs = [], executablePath }, promptModeOverride) {
     // 1. Gemini Models
     if (agent.model.startsWith("gemini-")) {
@@ -34,7 +79,13 @@ export function buildCommand({ agent, prompt, optionsArgs = [], executablePath }
     // 2. Claude Models
     if (agent.model.startsWith("claude-")) {
         const command = executablePath ?? process.env.CLAUDE_BIN ?? "claude";
-        const args = ["-p", prompt, "--model", agent.model];
+        const args = ["-p", prompt];
+        if (optionsArgs.length > 0) {
+            args.push(...optionsArgs);
+        }
+        if (!args.includes("--model") && !args.includes("-m")) {
+            args.push("--model", agent.model);
+        }
         return { command, args, promptMode: "args" };
     }
     // 3. Generic Codex/Other Models
@@ -81,11 +132,11 @@ export function spawnAgentProcess(config) {
     const { agent, optionsArgs = [] } = config;
     const startedAt = new Date().toISOString();
     const isCodexModel = !agent.model.startsWith("gemini-") && !agent.model.startsWith("claude-");
-    const sanitizedOptions = agent.model.startsWith("claude-")
-        ? []
-        : optionsArgs;
+    const sanitizedOptions = optionsArgs;
     const spawnWithMode = (promptModeOverride) => {
         const { command, args, promptMode } = buildCommand({ ...config, optionsArgs: sanitizedOptions }, promptModeOverride);
+        // Ensure requested project/working directories exist before launching CLI.
+        ensureDirectoriesExist(collectDirectoriesFromArgs(args));
         const ttyMode = process.env.CODEX_TTY_MODE ?? DEFAULT_TTY_MODE;
         const hasExec = args.includes("exec");
         const useScriptWrapper = ttyMode === "script" || (ttyMode === "auto" && hasExec);

package/dist/prompt-compact.js

@@ -0,0 +1,175 @@
+const DEFAULT_MAX_CHARS = 200_000;
+const DEFAULT_THRESHOLD_RATIO = 0.9;
+const DEFAULT_TARGET_RATIO = 0.85;
+const DEFAULT_SUMMARY_MAX_LINES = 20;
+function parseEnvInt(value) {
+    if (!value)
+        return null;
+    const parsed = Number.parseInt(value, 10);
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : null;
+}
+function parseEnvMode(value) {
+    if (!value)
+        return null;
+    const normalized = value.trim().toLowerCase();
+    if (normalized === "auto" ||
+        normalized === "summary" ||
+        normalized === "truncate" ||
+        normalized === "off") {
+        return normalized;
+    }
+    return null;
+}
+function clamp(value, min, max) {
+    return Math.max(min, Math.min(max, value));
+}
+function resolveEnvValue(env, keys) {
+    for (const key of keys) {
+        const value = env[key];
+        if (value !== undefined)
+            return value;
+    }
+    return undefined;
+}
+export function resolvePromptCompactionPolicy(env = process.env) {
+    const maxChars = parseEnvInt(resolveEnvValue(env, ["AGENT_LINK_PROMPT_CHAR_LIMIT", "CODEX_PROMPT_CHAR_LIMIT"])) ??
+        DEFAULT_MAX_CHARS;
+    const thresholdCharsEnv = parseEnvInt(resolveEnvValue(env, ["AGENT_LINK_PROMPT_CHAR_THRESHOLD", "CODEX_PROMPT_CHAR_THRESHOLD"]));
+    const targetCharsEnv = parseEnvInt(resolveEnvValue(env, ["AGENT_LINK_PROMPT_CHAR_TARGET", "CODEX_PROMPT_CHAR_TARGET"]));
+    const thresholdChars = thresholdCharsEnv ?? Math.floor(maxChars * DEFAULT_THRESHOLD_RATIO);
+    const targetChars = targetCharsEnv ?? Math.floor(maxChars * DEFAULT_TARGET_RATIO);
+    const mode = parseEnvMode(resolveEnvValue(env, ["AGENT_LINK_PROMPT_COMPACT", "CODEX_PROMPT_COMPACT"])) ??
+        "auto";
+    const summaryMaxLines = parseEnvInt(resolveEnvValue(env, ["AGENT_LINK_PROMPT_SUMMARY_LINES", "CODEX_PROMPT_SUMMARY_LINES"])) ??
+        DEFAULT_SUMMARY_MAX_LINES;
+    return {
+        maxChars,
+        thresholdChars: clamp(thresholdChars, 1, maxChars),
+        targetChars: clamp(targetChars, 1, maxChars),
+        mode,
+        summaryMaxLines,
+    };
+}
+function truncateByPreservingEdges(prompt, targetChars) {
+    if (prompt.length <= targetChars)
+        return prompt;
+    const marker = "\n\n[...prompt truncated...]\n\n";
+    if (targetChars <= marker.length + 1) {
+        return prompt.slice(0, targetChars);
+    }
+    const available = targetChars - marker.length;
+    const headLen = Math.floor(available * 0.6);
+    const tailLen = available - headLen;
+    return `${prompt.slice(0, headLen)}${marker}${prompt.slice(prompt.length - tailLen)}`;
+}
+function extractKeyLines(text, maxLines) {
+    const lines = text.split(/\r?\n/);
+    const picked = [];
+    const seen = new Set();
+    for (const rawLine of lines) {
+        const line = rawLine.trim();
+        if (line.length === 0)
+            continue;
+        const isHeading = /^(#+\s+|[*-]\s+|[A-Z][\w\s-]{0,40}:)/.test(line);
+        const isSignal = /(ERROR|WARN|WARNING|TODO|FIXME|NOTE|IMPORTANT)/i.test(line);
+        if (!isHeading && !isSignal)
+            continue;
+        if (line.length > 160)
+            continue;
+        if (seen.has(line))
+            continue;
+        seen.add(line);
+        picked.push(line);
+        if (picked.length >= maxLines)
+            break;
+    }
+    return picked;
+}
+function buildSummary(removed, maxChars, maxLines) {
+    if (maxChars <= 0)
+        return "";
+    const header = "SUMMARY OF REMOVED CONTENT:\n";
+    const lines = extractKeyLines(removed, maxLines);
+    const body = lines.length > 0
+        ? lines.map((line) => `- ${line}`).join("\n")
+        : "Summary unavailable; content removed.";
+    let summary = `${header}${body}`;
+    if (summary.length > maxChars) {
+        summary = summary.slice(0, Math.max(0, maxChars - 3)).trimEnd() + "...";
+    }
+    return summary;
+}
+function compactWithSummary(prompt, targetChars, maxLines) {
+    if (prompt.length <= targetChars)
+        return prompt;
+    const marker = "\n\n[...prompt compacted; middle summarized...]\n\n";
+    const spacer = "\n\n";
+    let headBudget = Math.floor(targetChars * 0.3);
+    let tailBudget = Math.floor(targetChars * 0.3);
+    let summaryBudget = targetChars - headBudget - tailBudget - marker.length - spacer.length;
+    if (summaryBudget < 50) {
+        return truncateByPreservingEdges(prompt, targetChars);
+    }
+    const head = prompt.slice(0, headBudget);
+    const tail = prompt.slice(prompt.length - tailBudget);
+    const removed = prompt.slice(headBudget, prompt.length - tailBudget);
+    const summary = buildSummary(removed, summaryBudget, maxLines);
+    const compacted = `${head}${marker}${summary}${spacer}${tail}`;
+    if (compacted.length <= targetChars) {
+        return compacted;
+    }
+    return truncateByPreservingEdges(compacted, targetChars);
+}
+export function compactPrompt(prompt, policy) {
+    const originalLength = prompt.length;
+    if (originalLength === 0) {
+        return { prompt, originalLength, finalLength: 0, action: "none" };
+    }
+    const maxChars = Math.max(1, policy.maxChars);
+    const thresholdChars = clamp(policy.thresholdChars, 1, maxChars);
+    const targetChars = clamp(policy.targetChars, 1, maxChars);
+    if (originalLength <= thresholdChars) {
+        return { prompt, originalLength, finalLength: originalLength, action: "none" };
+    }
+    if (policy.mode === "off") {
+        if (originalLength <= maxChars) {
+            return { prompt, originalLength, finalLength: originalLength, action: "none" };
+        }
+        const truncated = truncateByPreservingEdges(prompt, maxChars);
+        return {
+            prompt: truncated,
+            originalLength,
+            finalLength: truncated.length,
+            action: "truncate",
+            reason: "hard-limit",
+        };
+    }
+    if (policy.mode === "truncate") {
+        const truncated = truncateByPreservingEdges(prompt, targetChars);
+        return {
+            prompt: truncated,
+            originalLength,
+            finalLength: truncated.length,
+            action: "truncate",
+            reason: "policy-truncate",
+        };
+    }
+    const summarized = compactWithSummary(prompt, targetChars, policy.summaryMaxLines);
+    if (summarized.length <= targetChars) {
+        return {
+            prompt: summarized,
+            originalLength,
+            finalLength: summarized.length,
+            action: "summary",
+            reason: "policy-summary",
+        };
+    }
+    const truncated = truncateByPreservingEdges(summarized, targetChars);
+    return {
+        prompt: truncated,
+        originalLength,
+        finalLength: truncated.length,
+        action: "truncate",
+        reason: "summary-overflow",
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@span-io/agent-link",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "Secure bridge between Span (AI control plane) and local agent CLI tools.",
   "type": "module",
   "bin": {