doer-agent 0.3.0 → 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 [];
@@ -1256,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(),
     };
@@ -1306,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);
@@ -2275,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");
@@ -2435,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) {
@@ -3879,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.3.0",
+  "version": "0.3.1",
   "description": "Reverse-polling agent runtime for doer",
   "type": "module",
   "main": "dist/agent.js",