@jjlabsio/claude-crew 0.1.40 → 0.1.41

package/.claude-plugin/marketplace.json

@@ -11,7 +11,7 @@
       "name": "claude-crew",
       "source": "./",
       "description": "오케스트레이터 + PM, 플래너, 개발, QA, 마케팅 에이전트 팀으로 단일 제품의 개발과 마케팅을 통합 관리",
-      "version": "0.1.40",
+      "version": "0.1.41",
       "author": {
         "name": "Jaejin Song",
         "email": "wowlxx28@gmail.com"
@@ -28,5 +28,5 @@
       "category": "workflow"
     }
   ],
-  "version": "0.1.40"
+  "version": "0.1.41"
 }

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-crew",
-  "version": "0.1.40",
+  "version": "0.1.41",
   "description": "1인 SaaS 개발자를 위한 멀티 에이전트 오케스트레이션 — 개발, 마케팅, 일정을 한 대화에서 통합 관리",
   "author": {
     "name": "Jaejin Song",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jjlabsio/claude-crew",
-  "version": "0.1.40",
+  "version": "0.1.41",
   "description": "1인 SaaS 개발자를 위한 멀티 에이전트 오케스트레이션 — 개발, 마케팅, 일정을 한 대화에서 통합 관리",
   "author": "Jaejin Song <wowlxx28@gmail.com>",
   "license": "MIT",

package/scripts/crew-agent-runner.mjs

@@ -9,6 +9,10 @@ import {
   loadUserConfig
 } from "./lib/config.mjs";
 import { parseArgv } from "./lib/cli.mjs";
+import {
+  persistCrewArtifact,
+  ArtifactPersistError
+} from "./lib/artifacts.mjs";
 import {
   dispatch,
   DispatchError,
@@ -42,6 +46,10 @@ async function main(argv) {
     return dispatchCommand(flags);
   }
 
+  if (command === "persist-artifact") {
+    return persistArtifactCommand(flags);
+  }
+
   if (command === "render-followup") {
     return renderFollowupCommand(flags);
   }
@@ -224,6 +232,61 @@ function renderFollowupCommand(flags) {
   }
 }
 
+async function persistArtifactCommand(flags) {
+  if (typeof flags.role !== "string" || flags.role.length === 0) {
+    console.error("Missing required --role <name>");
+    return 1;
+  }
+
+  if (
+    typeof flags["result-file"] !== "string" ||
+    flags["result-file"].length === 0
+  ) {
+    console.error("Missing required --result-file <path>");
+    return 1;
+  }
+
+  if (
+    typeof flags["request-file"] !== "string" ||
+    flags["request-file"].length === 0
+  ) {
+    console.error("Missing required --request-file <path>");
+    return 1;
+  }
+
+  try {
+    const contracts = loadContracts();
+    const contract = findContract(flags.role, contracts);
+    if (!contract) {
+      throw new Error(`Unknown role: ${flags.role}`);
+    }
+
+    const agentResult = JSON.parse(readFileSync(flags["result-file"], "utf8"));
+    const request = JSON.parse(readFileSync(flags["request-file"], "utf8"));
+
+    const savedPath = await persistCrewArtifact({
+      workspaceRoot: process.cwd(),
+      contract,
+      request,
+      agentResult
+    });
+
+    if (savedPath) {
+      process.stdout.write(`${JSON.stringify({ artifact_path: savedPath })}\n`);
+    } else {
+      process.stdout.write(`${JSON.stringify({ artifact_path: null })}\n`);
+    }
+    return 0;
+  } catch (error) {
+    if (error instanceof ArtifactPersistError) {
+      console.error(error.message);
+      return 1;
+    }
+    console.error(error.message);
+    return 1;
+  }
+}
+
 async function dispatchCommand(flags) {
   if (typeof flags.role !== "string" || flags.role.length === 0) {
     console.error("Missing required --role <name>");
@@ -376,6 +439,9 @@ function usage() {
   console.error(
     "       crew-agent-runner dispatch --role <name> --request-file <path> [--json] [--resume-handle <thread-id>]"
   );
+  console.error(
+    "       crew-agent-runner persist-artifact --role <name> --result-file <path> --request-file <path>"
+  );
 }
 
 const exitCode = await main(process.argv.slice(2));

package/scripts/lib/artifacts.mjs

@@ -0,0 +1,89 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import { dirname, normalize, resolve, relative } from "node:path";
+
+export class ArtifactPersistError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ArtifactPersistError";
+  }
+}
+
+export async function persistCrewArtifact({ workspaceRoot, contract, request, agentResult }) {
+  if (!shouldPersist(contract, agentResult)) {
+    return null;
+  }
+
+  const target = findArtifactTarget(contract);
+  if (!target) {
+    return null;
+  }
+
+  const resolvedTarget = replaceTaskId(target, request?.taskId);
+  const absolutePath = validateTargetPath(workspaceRoot, resolvedTarget);
+
+  await mkdir(dirname(absolutePath), { recursive: true });
+  await writeFile(absolutePath, agentResult.artifact, "utf8");
+
+  return absolutePath;
+}
+
+function shouldPersist(contract, agentResult) {
+  if (contract?.capabilities?.workspaceAccess !== "read-only") {
+    return false;
+  }
+
+  if (agentResult?.status !== "complete") {
+    return false;
+  }
+
+  if (typeof agentResult.artifact !== "string" || agentResult.artifact.length === 0) {
+    return false;
+  }
+
+  return true;
+}
+
+function findArtifactTarget(contract) {
+  const outputs = Array.isArray(contract?.outputs) ? contract.outputs : [];
+  for (const output of outputs) {
+    if (
+      output?.type === "artifact" &&
+      typeof output.target === "string" &&
+      output.target.startsWith(".crew/")
+    ) {
+      return output.target;
+    }
+  }
+  return null;
+}
+
+function replaceTaskId(target, taskId) {
+  if (typeof taskId === "string" && taskId.length > 0) {
+    return target.replace(/\{task-id\}/g, taskId);
+  }
+  return target;
+}
+
+function validateTargetPath(workspaceRoot, target) {
+  if (!workspaceRoot || typeof workspaceRoot !== "string") {
+    throw new ArtifactPersistError("workspaceRoot is required.");
+  }
+
+  const normalized = normalize(target);
+
+  if (normalized.startsWith("/") || normalized.startsWith("\\")) {
+    throw new ArtifactPersistError(`Absolute path rejected: ${target}`);
+  }
+
+  const crewBase = resolve(workspaceRoot, ".crew");
+  const absolutePath = resolve(workspaceRoot, normalized);
+  const rel = relative(crewBase, absolutePath);
+
+  if (rel.startsWith("..") || rel === "") {
+    throw new ArtifactPersistError(
+      `Target path escapes .crew/ directory: ${target}`
+    );
+  }
+
+  return absolutePath;
+}

package/scripts/lib/dispatch.mjs

@@ -4,6 +4,7 @@ import { tmpdir } from "node:os";
 import { basename, join } from "node:path";
 import { fileURLToPath } from "node:url";
 
+import { persistCrewArtifact, ArtifactPersistError } from "./artifacts.mjs";
 import { renderPrompt } from "./render.mjs";
 
 const DEFAULT_COMPANION = fileURLToPath(
@@ -84,6 +85,11 @@ export async function dispatch(input) {
       });
     }
 
+    const artifactPath = await persistArtifactSafe(input, agentResult);
+    if (artifactPath) {
+      return { ...agentResult, artifact_path: artifactPath };
+    }
+
     return agentResult;
   } finally {
     await rm(tmpDir, { recursive: true, force: true });
@@ -235,6 +241,24 @@ function resolveCompanion(input = {}) {
   };
 }
 
+async function persistArtifactSafe(input, agentResult) {
+  try {
+    return await persistCrewArtifact({
+      workspaceRoot: process.cwd(),
+      contract: input.contract,
+      request: input.request,
+      agentResult
+    });
+  } catch (error) {
+    if (error instanceof ArtifactPersistError) {
+      throw new DispatchError(`Artifact persist failed: ${error.message}`, {
+        agentResult
+      });
+    }
+    throw error;
+  }
+}
+
 function isNodeScript(value) {
   const name = basename(String(value));
   return name.endsWith(".mjs") || name.endsWith(".js");

package/scripts/lib/render.mjs

@@ -8,7 +8,7 @@ export function renderPrompt(input) {
     section("Instructions", request.instruction, { required: true }),
     section("Success Gate", request.successGate),
     section("Failure Handling", request.failureHandling),
-    section("AgentResult Contract", renderAgentResultContract())
+    section("AgentResult Contract", renderAgentResultContract(contract))
   ].filter(Boolean);
 
   return `${parts.join("\n\n")}\n`;
@@ -41,7 +41,7 @@ function renderCapability(contract) {
     `canAskUser: ${String(tools.includes("AskUserQuestion"))}`,
     `canRequestAgent: ${String(tools.includes("Agent"))}`,
     `canUseShell: ${String(tools.includes("Bash"))}`,
-    `canWriteCrewFiles: ${String(canWriteCrewFiles(outputs))}`
+    `canReturnCrewArtifact: ${String(canReturnCrewArtifact(outputs, contract.capabilities?.workspaceAccess))}`
   ].join("\n");
 }
 
@@ -73,15 +73,19 @@ function renderJson(value) {
   return JSON.stringify(value, null, 2);
 }
 
-function renderAgentResultContract() {
-  return [
+function renderAgentResultContract(contract = {}) {
+  const outputs = Array.isArray(contract.outputs) ? contract.outputs : [];
+  const workspaceAccess = contract.capabilities?.workspaceAccess;
+  const returnArtifact = canReturnCrewArtifact(outputs, workspaceAccess);
+
+  const lines = [
     "Return exactly one final AgentResult JSON object wrapped in these tags:",
     "",
     "```text",
     "<crew-agent-result>",
     "{",
     '  "status": "complete | blocked_on_user | needs_agent | needs_tool | failed",',
-    '  "artifact": null,',
+    `  "artifact": ${returnArtifact ? '"full Markdown content of the artifact"' : "null"},`,
     '  "questions": [],',
     '  "requests": [],',
     '  "summary": "short summary",',
@@ -97,7 +101,15 @@ function renderAgentResultContract() {
     "- Use blocked_on_user only with a non-empty questions array.",
     "- Use needs_agent or needs_tool only with a non-empty requests array.",
     "- Use failed with an error string when the task cannot continue."
-  ].join("\n");
+  ];
+
+  if (returnArtifact) {
+    lines.push(
+      "- Do NOT write the artifact file yourself. Instead, put the full Markdown content into the artifact field as a string. The runner will validate and save it to the target path."
+    );
+  }
+
+  return lines.join("\n");
 }
 
 function normalizeBody(body) {
@@ -127,7 +139,11 @@ function titleCase(value) {
     .join("-");
 }
 
-function canWriteCrewFiles(outputs) {
+export function canReturnCrewArtifact(outputs, workspaceAccess) {
+  if (workspaceAccess !== "read-only") {
+    return false;
+  }
+
   return outputs.some((output) => {
     return (
       output?.type === "artifact" &&