doer-agent 0.2.9 → 0.3.1

package/dist/agent.js

@@ -16,6 +16,7 @@ const sessionRpcCodec = StringCodec();
 const codexAuthRpcCodec = StringCodec();
 const settingsRpcCodec = StringCodec();
 const gitRpcCodec = StringCodec();
+const skillRpcCodec = StringCodec();
 const retainedRuns = new Map();
 const activeSessionWatchers = new Map();
 const sessionLineIndexCache = new Map();
@@ -40,6 +41,9 @@ function buildAgentSettingsRpcSubject(userId, agentId) {
 function buildAgentGitRpcSubject(userId, agentId) {
     return `doer.agent.git.rpc.${sanitizeUserId(userId)}.${agentId.trim()}`;
 }
+function buildAgentSkillRpcSubject(userId, agentId) {
+    return `doer.agent.skill.rpc.${sanitizeUserId(userId)}.${agentId.trim()}`;
+}
 function normalizeNatsServers(value) {
     if (!Array.isArray(value)) {
         return [];
@@ -286,6 +290,25 @@ function normalizeEnvPatch(value) {
     }
     return out;
 }
+function normalizeRunImagePaths(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    const seen = new Set();
+    const out = [];
+    for (const item of value) {
+        if (typeof item !== "string") {
+            continue;
+        }
+        const normalized = item.trim();
+        if (!normalized || seen.has(normalized)) {
+            continue;
+        }
+        seen.add(normalized);
+        out.push(normalized);
+    }
+    return out;
+}
 async function prepareTaskRuntimeConfig(args) {
     const bundle = await postJson(`${args.serverBaseUrl}/api/agent/tasks/${encodeURIComponent(args.taskId)}/runtime-config`, {
         userId: args.userId,
@@ -408,6 +431,7 @@ function normalizeRunRpcRequest(args) {
     }
     const runId = typeof args.request.runId === "string" && args.request.runId.trim() ? args.request.runId.trim() : null;
     const prompt = typeof args.request.prompt === "string" && args.request.prompt.trim() ? args.request.prompt.trim() : null;
+    const imagePaths = normalizeRunImagePaths(args.request.imagePaths);
     const sessionId = typeof args.request.sessionId === "string" && args.request.sessionId.trim() ? args.request.sessionId.trim() : null;
     const model = normalizeCodexModel(args.request.model);
     if (action === "start" && !prompt) {
@@ -426,6 +450,7 @@ function normalizeRunRpcRequest(args) {
         action,
         runId,
         prompt,
+        imagePaths,
         sessionId,
         model,
         cwd,
@@ -1185,13 +1210,14 @@ function normalizeCodexModel(value) {
 function buildManagedCodexArgs(args) {
     const promptArgs = ["--", args.prompt];
     const fixedArgs = ["--dangerously-bypass-approvals-and-sandbox"];
+    const imageArgs = args.imagePaths.flatMap((imagePath) => ["--image", imagePath]);
     return [
         ...fixedArgs,
         "--model",
         args.model,
         ...(args.sessionId
-            ? ["exec", "resume", "--json", args.sessionId, ...promptArgs]
-            : ["exec", "--json", ...promptArgs]),
+            ? ["exec", "resume", "--json", ...imageArgs, args.sessionId, ...promptArgs]
+            : ["exec", "--json", ...imageArgs, ...promptArgs]),
     ];
 }
 function buildLocalCodexCliCommand(args) {
@@ -1234,11 +1260,12 @@ function spawnManagedCodexCommand(args) {
     child.stderr?.setEncoding("utf8");
     return child;
 }
-async function runLocalCodexCli(args, timeoutMs) {
+async function runLocalCodexCli(args, timeoutMs, envPatch) {
     const command = buildLocalCodexCliCommand(args);
     const workspaceRoot = workspaceRootOverride ?? (process.env.WORKSPACE?.trim() || process.cwd());
     const env = {
         ...process.env,
+        ...(envPatch ?? {}),
         WORKSPACE: workspaceRoot,
         CODEX_HOME: resolveCodexHomePath(),
     };
@@ -1284,6 +1311,152 @@ async function runLocalCodexCli(args, timeoutMs) {
         });
     });
 }
+function buildSkillGeneratorPrompt(userPrompt) {
+    return [
+        "Create a Codex skill from the user's description.",
+        "",
+        "Return JSON only with this shape:",
+        '{ "skillName": "kebab-or-dot-or-underscore-name", "skillMd": "full SKILL.md content" }',
+        "",
+        "Requirements:",
+        "- skillName must be lowercase ASCII and use only letters, numbers, dot, underscore, or dash.",
+        "- skillName must not start with a dot and must not be .system.",
+        "- skillMd must be a complete SKILL.md file.",
+        "- skillMd must start with YAML frontmatter containing name and description.",
+        "- Keep the skill concise and action-oriented.",
+        "- Include when to use the skill, the core workflow, and any important constraints.",
+        "- Do not add README, changelog, or any extra files.",
+        "",
+        "User request:",
+        userPrompt.trim(),
+    ].join("\n");
+}
+function extractJsonObject(value) {
+    const trimmed = value.trim();
+    if (trimmed.startsWith("{") && trimmed.endsWith("}")) {
+        return trimmed;
+    }
+    const fenced = trimmed.match(/```(?:json)?\s*([\s\S]*?)```/i);
+    if (fenced?.[1]) {
+        return fenced[1].trim();
+    }
+    const start = trimmed.indexOf("{");
+    const end = trimmed.lastIndexOf("}");
+    if (start >= 0 && end > start) {
+        return trimmed.slice(start, end + 1);
+    }
+    throw new Error("Codex did not return JSON");
+}
+function slugifySkillName(value) {
+    return value
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9._-]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .replace(/-{2,}/g, "-");
+}
+function normalizeGeneratedSkill(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new Error("Invalid generated skill payload");
+    }
+    const row = value;
+    const skillName = slugifySkillName(typeof row.skillName === "string" ? row.skillName : "");
+    const skillMd = typeof row.skillMd === "string" ? row.skillMd.trim() : "";
+    if (!skillName || skillName.startsWith(".") || skillName === ".system") {
+        throw new Error("Codex returned an invalid skill name");
+    }
+    if (!skillMd) {
+        throw new Error("Codex returned an empty SKILL.md");
+    }
+    if (!/^---\s*\n[\s\S]*?\n---\s*\n/m.test(skillMd)) {
+        throw new Error("Generated SKILL.md is missing YAML frontmatter");
+    }
+    if (!/\nname:\s*[^\n]+/i.test(skillMd) || !/\ndescription:\s*[^\n]+/i.test(skillMd)) {
+        throw new Error("Generated SKILL.md frontmatter is incomplete");
+    }
+    return { skillName, skillMd };
+}
+function buildSkillGeneratorCodexArgs(prompt, model) {
+    return ["--dangerously-bypass-approvals-and-sandbox", "--model", model, "exec", "--", prompt];
+}
+async function generateSkillViaCodex(userPrompt) {
+    const localAgentSettings = await readAgentSettingsConfig(null);
+    const envPatch = buildAgentSettingsEnvPatch(localAgentSettings);
+    const prompt = buildSkillGeneratorPrompt(userPrompt);
+    const result = await runLocalCodexCli(buildSkillGeneratorCodexArgs(prompt, localAgentSettings.codex.model || "gpt-5.4"), 120_000, envPatch);
+    if (result.timedOut) {
+        throw new Error("Codex timed out while generating the skill");
+    }
+    if ((result.code ?? 1) !== 0) {
+        const details = stripAnsi(result.stderr || result.stdout).trim();
+        throw new Error(details || `Codex exited with code ${result.code ?? "null"}`);
+    }
+    const payload = JSON.parse(extractJsonObject(stripAnsi(result.stdout)));
+    const generated = normalizeGeneratedSkill(payload);
+    const skillPath = path.join(resolveCodexHomePath(), "skills", generated.skillName);
+    const skillFilePath = path.join(skillPath, "SKILL.md");
+    try {
+        await stat(skillPath);
+        throw new Error("A skill with that name already exists");
+    }
+    catch (error) {
+        if (!(error instanceof Error) || !/ENOENT/i.test(error.message)) {
+            throw error;
+        }
+    }
+    await mkdir(skillPath, { recursive: true });
+    await writeFile(skillFilePath, `${generated.skillMd}\n`, "utf8");
+    return {
+        skillName: generated.skillName,
+        skillPath: `.codex/skills/${generated.skillName}`,
+        skillFilePath: `.codex/skills/${generated.skillName}/SKILL.md`,
+    };
+}
+async function handleSkillRpcMessage(args) {
+    let payload = {};
+    try {
+        payload = JSON.parse(skillRpcCodec.decode(args.msg.data));
+        if (typeof payload.agentId === "string" && payload.agentId.trim() && payload.agentId !== args.agentId) {
+            throw new Error("agent id mismatch");
+        }
+        const prompt = typeof payload.prompt === "string" ? payload.prompt.trim() : "";
+        if (!prompt) {
+            throw new Error("prompt is required");
+        }
+        const result = await generateSkillViaCodex(prompt);
+        args.msg.respond(skillRpcCodec.encode(JSON.stringify({
+            ok: true,
+            skillName: result.skillName,
+            skillPath: result.skillPath,
+            skillFilePath: result.skillFilePath,
+        })));
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "unknown error";
+        args.msg.respond(skillRpcCodec.encode(JSON.stringify({
+            ok: false,
+            error: message,
+        })));
+        writeAgentError(`skill rpc failed error=${message}`);
+    }
+}
+function subscribeToSkillRpc(args) {
+    const subject = buildAgentSkillRpcSubject(args.userId, args.agentId);
+    args.jetstream.nc.subscribe(subject, {
+        callback: (error, msg) => {
+            if (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                writeAgentError(`skill rpc subscription error: ${message}`);
+                return;
+            }
+            void handleSkillRpcMessage({
+                msg,
+                agentId: args.agentId,
+            });
+        },
+    });
+    writeAgentInfo(`skill rpc subscribed subject=${subject}`);
+}
 function parseCodexDeviceAuthOutput(raw) {
     const text = stripAnsi(raw);
     const urlMatch = text.match(/https?:\/\/[^\s]+/i);
@@ -1962,6 +2135,7 @@ async function handleRunRpcMessage(args) {
                     sessionId: request.sessionId,
                     codexArgs: buildManagedCodexArgs({
                         prompt: request.prompt ?? "",
+                        imagePaths: request.imagePaths,
                         sessionId: request.sessionId,
                         model: request.model,
                     }),
@@ -2252,7 +2426,8 @@ function parseFsRpcAction(value) {
         value === "read_text" ||
         value === "read_file" ||
         value === "write_file" ||
-        value === "download_file") {
+        value === "download_file" ||
+        value === "delete_path") {
         return value;
     }
     throw new Error("unsupported action");
@@ -2412,6 +2587,15 @@ async function executeFsRpc(args) {
             mtimeMs: entry.mtimeMs,
         };
     }
+    if (action === "delete_path") {
+        await rm(abs, { recursive: true, force: true });
+        return {
+            ok: true,
+            action,
+            path: formatPath(abs),
+            absolutePath: abs.split(path.sep).join("/"),
+        };
+    }
     if (action === "download_file") {
         const downloadPath = typeof args.request.downloadPath === "string" ? args.request.downloadPath.trim() : "";
         if (!downloadPath) {
@@ -2611,9 +2795,19 @@ function sanitizeSessionRpcRawLine(line) {
     }
     try {
         const parsed = JSON.parse(line);
-        if (!isObjectRecord(parsed) || !isObjectRecord(parsed.payload) || parsed.type !== "response_item") {
+        if (!isObjectRecord(parsed)) {
             return line;
         }
+        if (parsed.type === "compacted" || parsed.type === "turn_context" || parsed.type === "session_meta") {
+            return null;
+        }
+        if (!isObjectRecord(parsed.payload) || parsed.type !== "response_item") {
+            return line;
+        }
+        const payloadType = typeof parsed.payload.type === "string" ? parsed.payload.type : "";
+        if (payloadType === "message" || payloadType === "reasoning") {
+            return null;
+        }
         return JSON.stringify({
             ...parsed,
             payload: sanitizeSessionRpcPayload(parsed.payload),
@@ -3007,9 +3201,14 @@ async function getAgentSessionRawRows(args) {
         let lineNumber = startLineIndex + 1;
         for (const line of lines) {
             if (line.trim()) {
+                const sanitized = sanitizeSessionRpcRawLine(line);
+                if (!sanitized) {
+                    lineNumber += 1;
+                    continue;
+                }
                 rawRows.push({
                     id: lineNumber,
-                    raw: sanitizeSessionRpcRawLine(line),
+                    raw: sanitized,
                 });
             }
             lineNumber += 1;
@@ -3841,6 +4040,11 @@ async function main() {
             userId,
             agentId: initialAgentId,
         });
+        subscribeToSkillRpc({
+            jetstream,
+            userId,
+            agentId: initialAgentId,
+        });
         subscribeToRunRpc({
             jetstream,
             serverBaseUrl,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "doer-agent",
-  "version": "0.2.9",
+  "version": "0.3.1",
   "description": "Reverse-polling agent runtime for doer",
   "type": "module",
   "main": "dist/agent.js",