doer-agent 0.3.0 → 0.3.2

package/dist/agent.js

@@ -1,8 +1,9 @@
 import { spawn, spawnSync } from "node:child_process";
 import { existsSync, statSync, watch } from "node:fs";
-import { chmod, mkdir, open, readFile, readdir, rename, rm, rmdir, stat, unlink, writeFile } from "node:fs/promises";
+import { chmod, mkdir, open, readFile, readdir, realpath, rename, rm, rmdir, stat, unlink, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
+import { gunzipSync, gzipSync } from "node:zlib";
 import { AckPolicy, connect, DeliverPolicy, JSONCodec, RetentionPolicy, StorageType, StringCodec } from "nats";
 const DEFAULT_SERVER_BASE_URL = "https://doer.cranix.net";
 const AGENT_MODULE_DIR = path.dirname(fileURLToPath(import.meta.url));
@@ -16,6 +17,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 +42,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 [];
@@ -1256,11 +1261,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(),
     };
@@ -1306,6 +1312,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);
@@ -2275,7 +2427,10 @@ function parseFsRpcAction(value) {
         value === "read_text" ||
         value === "read_file" ||
         value === "write_file" ||
-        value === "download_file") {
+        value === "download_file" ||
+        value === "delete_path" ||
+        value === "archive_dir" ||
+        value === "extract_archive") {
         return value;
     }
     throw new Error("unsupported action");
@@ -2333,6 +2488,34 @@ function inferMimeType(filePath) {
     }
     return "application/octet-stream";
 }
+function normalizeArchiveRelativePath(value) {
+    const normalized = value.replace(/\\/g, "/").replace(/^\/+|\/+$/g, "");
+    if (!normalized || normalized.includes("..")) {
+        throw new Error("invalid archive entry path");
+    }
+    return normalized;
+}
+async function collectDirectoryFiles(absDir, rootDir = absDir) {
+    const rows = await readdir(absDir, { withFileTypes: true });
+    const files = [];
+    for (const row of rows.sort((a, b) => a.name.localeCompare(b.name))) {
+        const child = path.join(absDir, row.name);
+        if (row.isDirectory()) {
+            files.push(...await collectDirectoryFiles(child, rootDir));
+            continue;
+        }
+        if (!row.isFile()) {
+            continue;
+        }
+        const bytes = await readFile(child);
+        files.push({
+            relPath: normalizeArchiveRelativePath(path.relative(rootDir, child)),
+            contentBase64: Buffer.from(bytes).toString("base64"),
+            sizeBytes: bytes.byteLength,
+        });
+    }
+    return files;
+}
 async function executeFsRpc(args) {
     const action = parseFsRpcAction(args.request.action);
     const { abs, formatPath } = normalizeFsRpcPath(args.request.path);
@@ -2375,6 +2558,34 @@ async function executeFsRpc(args) {
             total: items.length,
         };
     }
+    if (action === "archive_dir") {
+        const entry = await stat(abs);
+        if (!entry.isDirectory()) {
+            throw new Error("path is not a directory");
+        }
+        const rawArchivePath = typeof args.request.archivePath === "string" ? args.request.archivePath : "";
+        if (!rawArchivePath) {
+            throw new Error("archivePath is required");
+        }
+        const archiveTarget = normalizeFsRpcPath(rawArchivePath);
+        const files = await collectDirectoryFiles(abs);
+        if (!files.some((file) => file.relPath === "SKILL.md")) {
+            throw new Error("Selected skill directory must contain SKILL.md");
+        }
+        const payload = gzipSync(Buffer.from(JSON.stringify({
+            files,
+        }), "utf8"));
+        await mkdir(path.dirname(archiveTarget.abs), { recursive: true });
+        await writeFile(archiveTarget.abs, payload);
+        const archiveStat = await stat(archiveTarget.abs);
+        return {
+            ok: true,
+            action,
+            path: formatPath(abs),
+            archivePath: archiveTarget.formatPath(archiveTarget.abs),
+            size: archiveStat.size,
+        };
+    }
     if (action === "fetch_file") {
         const entry = await stat(abs);
         if (!entry.isFile()) {
@@ -2435,6 +2646,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) {
@@ -2466,6 +2686,37 @@ async function executeFsRpc(args) {
             mtimeMs: entry.mtimeMs,
         };
     }
+    if (action === "extract_archive") {
+        const archiveEntry = await stat(abs);
+        if (!archiveEntry.isFile()) {
+            throw new Error("path is not a file");
+        }
+        const rawDestinationPath = typeof args.request.destinationPath === "string" ? args.request.destinationPath : "";
+        if (!rawDestinationPath) {
+            throw new Error("destinationPath is required");
+        }
+        const destinationTarget = normalizeFsRpcPath(rawDestinationPath);
+        const archiveBytes = await readFile(abs);
+        const decoded = JSON.parse(gunzipSync(archiveBytes).toString("utf8"));
+        const files = Array.isArray(decoded.files) ? decoded.files : [];
+        await mkdir(destinationTarget.abs, { recursive: true });
+        for (const file of files) {
+            const relPath = typeof file.relPath === "string" ? normalizeArchiveRelativePath(file.relPath) : "";
+            const contentBase64 = typeof file.contentBase64 === "string" ? file.contentBase64 : "";
+            if (!relPath || !contentBase64) {
+                throw new Error("archive contains an invalid file entry");
+            }
+            const targetPath = path.join(destinationTarget.abs, relPath);
+            await mkdir(path.dirname(targetPath), { recursive: true });
+            await writeFile(targetPath, Buffer.from(contentBase64, "base64"));
+        }
+        return {
+            ok: true,
+            action,
+            path: formatPath(abs),
+            absolutePath: destinationTarget.formatPath(destinationTarget.abs),
+        };
+    }
     const entry = await stat(abs);
     if (!entry.isFile()) {
         throw new Error("path is not a file");
@@ -3112,6 +3363,7 @@ function stopAllSessionWatchers() {
 }
 async function startSessionWatch(args) {
     const resolvedFile = resolveSessionFilePath(args.filePath);
+    const canonicalFile = await realpath(resolvedFile).catch(() => resolvedFile);
     const watchId = `watch_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 10)}`;
     let watcher = null;
     let active = true;
@@ -3136,9 +3388,9 @@ async function startSessionWatch(args) {
             return;
         }
         active = false;
+        activeSessionWatchers.delete(watchId);
         watcher?.close();
         watcher = null;
-        activeSessionWatchers.delete(watchId);
     };
     const notifyFromContent = () => {
         emitEvent({
@@ -3146,8 +3398,13 @@ async function startSessionWatch(args) {
             at: formatLocalTimestamp(),
         });
     };
-    watcher = watch(resolvedFile, () => {
-        notifyFromContent();
+    watcher = watch(canonicalFile, { persistent: false }, (eventType) => {
+        if (!active) {
+            return;
+        }
+        if (eventType === "change" || eventType === "rename") {
+            notifyFromContent();
+        }
     });
     activeSessionWatchers.set(watchId, cleanup);
     emitEvent({ type: "stream.started", watchId, at: formatLocalTimestamp() });
@@ -3879,6 +4136,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.3.0",
+  "version": "0.3.2",
   "description": "Reverse-polling agent runtime for doer",
   "type": "module",
   "main": "dist/agent.js",