@mrrlin-dev/mcp 0.4.117 → 0.4.118

package/dist/bin.cjs

@@ -57873,6 +57873,70 @@ function registerLocalOnlyCheckout(registry3, input, machineLabel, options = {},
   registry3.confirm(input.projectSlug, validated.realPath, now);
   return { ok: true, data: { projectSlug: input.projectSlug, path: validated.realPath, confirmedAt: now, machineLabel } };
 }
+var DEFAULT_GITIGNORE = ["node_modules/", "dist/", "build/", ".DS_Store", ".env", ".env.*", "*.log", ""].join("\n");
+function runGit(realPath, args) {
+  return (0, import_node_child_process14.execFileSync)("git", ["-C", realPath, ...args], {
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"],
+    timeout: 6e4,
+    env: { ...process.env, GIT_TERMINAL_PROMPT: "0" }
+  }).trim();
+}
+function initLocalRepo(registry3, input, machineLabel, options = {}, now = (/* @__PURE__ */ new Date()).toISOString()) {
+  if (input.operatorConsent !== true) {
+    return {
+      ok: false,
+      code: "consent_required",
+      detail: "Ask the operator in chat, in plain words, whether their project folder may be turned into a git repository, and call this again only after they say yes."
+    };
+  }
+  const codeHost = input.project.codeHost ?? null;
+  if (!(codeHost === "local" || codeHost === null && !input.project.githubRepo)) {
+    return { ok: false, code: "not_local_project", detail: `Project ${input.projectSlug} keeps its code on ${codeHost ?? "GitHub"}.` };
+  }
+  const checked = checkLocalPathRules(input.path, options);
+  if (!checked.ok) return checked;
+  if (gitTopLevel(checked.realPath) !== null) {
+    return {
+      ok: false,
+      code: "inside_git_repo",
+      detail: `${checked.realPath} is already inside a git repository; register that repository with register_local_checkout instead.`
+    };
+  }
+  const recheck = checkLocalPathRules(checked.realPath, options);
+  if (!recheck.ok || recheck.realPath !== checked.realPath) {
+    return { ok: false, code: "path_changed", detail: `${checked.realPath} changed while it was being checked; nothing was done.` };
+  }
+  const realPath = recheck.realPath;
+  let wroteGitignore = false;
+  try {
+    runGit(realPath, ["init", "-q", "-b", "main"]);
+    const gitignore = import_node_path16.default.join(realPath, ".gitignore");
+    try {
+      (0, import_node_fs9.writeFileSync)(gitignore, DEFAULT_GITIGNORE, { flag: "wx" });
+      wroteGitignore = true;
+    } catch {
+    }
+    runGit(realPath, ["add", "-A"]);
+    runGit(realPath, [
+      "-c",
+      "user.name=Mrrlin",
+      "-c",
+      "user.email=bridge@mrrlin.local",
+      "commit",
+      "-q",
+      "--no-verify",
+      "--allow-empty",
+      "-m",
+      "Initial commit (Mrrlin)"
+    ]);
+  } catch (error51) {
+    return { ok: false, code: "init_failed", detail: error51 instanceof Error ? error51.message : String(error51) };
+  }
+  const initialCommit = runGit(realPath, ["rev-parse", "HEAD"]);
+  registry3.confirm(input.projectSlug, realPath, now);
+  return { ok: true, data: { projectSlug: input.projectSlug, path: realPath, confirmedAt: now, machineLabel, initialCommit, wroteGitignore } };
+}
 
 // src/operator-token.ts
 var import_node_fs10 = require("node:fs");
@@ -58021,6 +58085,8 @@ var mcpToolNames = {
   recordProducedUrl: "record_produced_url",
   updateTaskState: "update_task_state",
   registerLocalCheckout: "register_local_checkout",
+  initLocalRepo: "init_local_repo",
+  setProjectCodeHost: "set_project_code_host",
   /** Compact-context retrieval: rehydrate a mrrlin:// handle into the canonical full record. */
   retrieveContext: "retrieve_context"
 };
@@ -58729,6 +58795,13 @@ var registerLocalCheckoutInputSchema = projectScopedSchema.extend({
     "The project's bound GitHub repo full name in `owner/repo` form. Omit it for a project with no GitHub (its code lives only on this computer): the folder then only has to be a git repository the operator owns."
   )
 });
+var initLocalRepoInputSchema = projectScopedSchema.extend({
+  path: external_exports.string().min(1).describe("Absolute path to the operator's project folder (not inside any git repository)."),
+  operatorConsent: external_exports.literal(true).describe("true only after the operator explicitly agreed in chat that this folder may become a git repository.")
+});
+var setProjectCodeHostInputSchema = projectScopedSchema.extend({
+  codeHost: mrrlinProjectCodeHostSchema.nullable().describe("local = keep code only on this computer; github / gitlab = the operator wants to push there (connect it next); null = not decided.")
+});
 var retrieveContextInputSchema = external_exports.object({
   handle: external_exports.string().min(1).describe(
     "A mrrlin:// handle emitted in a compact envelope. Examples: mrrlin://task/{slug}/GT-123, mrrlin://wiki/{slug}/WK-1, mrrlin://project/{slug}/snapshot, mrrlin://run/{slug}/ER-9, mrrlin://run/{slug}/ER-9/artifacts."
@@ -58800,6 +58873,8 @@ var mcpToolInputSchemas = {
   [mcpToolNames.recordProducedUrl]: recordProducedUrlInputSchema,
   [mcpToolNames.updateTaskState]: updateTaskStateInputSchema,
   [mcpToolNames.registerLocalCheckout]: registerLocalCheckoutInputSchema,
+  [mcpToolNames.initLocalRepo]: initLocalRepoInputSchema,
+  [mcpToolNames.setProjectCodeHost]: setProjectCodeHostInputSchema,
   [mcpToolNames.retrieveContext]: retrieveContextInputSchema
 };
 var mcpToolOperationIds = {
@@ -58923,6 +58998,8 @@ var mcpToolDescriptions = {
   [mcpToolNames.stopExecutionRun]: "Operator stop: park an in-flight execution run at handoff_requested with blockingReason operator_stopped. Parks rather than cancels, so restart_execution_run can resume it later. Refuses (409) a run already at a terminal status.",
   [mcpToolNames.resolveHandoff]: "Resolve a tool_assisted handoff for an execution run (outcome success|failure). Success returns the task to the board; failure opens a new handoff cycle. Idempotent.",
   [mcpToolNames.registerLocalCheckout]: "Register the operator-local git checkout path for `projectSlug` so execution-run workers run code on this machine instead of the cloud. Validates the path is a git repo whose `origin` remote matches `repo`, then writes the (slug -> absolute path) entry to the operator-local checkout registry. For a project with no GitHub (code kept only on this computer), omit `repo`: the path must then be the top of a git repository owned by the operator, not the home folder or a system folder. Call this after locating the checkout on disk (e.g. via filesystem search) and confirming the choice with the user in chat \u2014 they should NOT have to paste the path into Settings. Returns `{ projectSlug, path, confirmedAt }`. Idempotent: re-registering overwrites the prior entry.",
+  [mcpToolNames.initLocalRepo]: "For a project with no GitHub whose folder is not a git repository yet: run `git init` and one initial commit in the operator's own folder, then register it. Call ONLY after asking the operator in chat, in plain words, and getting an explicit yes; pass operatorConsent: true. Refuses a folder already inside a git repository, the home folder, a filesystem root or a system folder. Adds a default .gitignore (node_modules, build output, .env files) only when the folder has none.",
+  [mcpToolNames.setProjectCodeHost]: "Record where this project's code lives, after the operator answered the code-host question: local (keep it on this computer), github or gitlab (they want to push there; connect it next). Does not move any code.",
   [mcpToolNames.retrieveContext]: "Rehydrate a mrrlin:// handle emitted by the compact-context layer into the full canonical Mrrlin record (task/wiki page/project snapshot/execution run/artifacts). Use whenever you need the full source \u2014 irreversible decisions (closing tasks, dispatching deploys, writing specs) MUST call this first; never act on a compact envelope alone. Returns `{ kind, data }`. Invalid or unsupported handle \u2192 structured `HANDLE_INVALID` error."
 };
 var ARTIFACT_EXTENSION_TYPES = {
@@ -60073,6 +60150,53 @@ function createMrrlinTools(options) {
         return result.data;
       }
     ),
+    [mcpToolNames.initLocalRepo]: makeTool(
+      client,
+      mcpToolNames.initLocalRepo,
+      "LOCAL_REPO_INIT_FAILED",
+      "Unable to initialise the local repository.",
+      async (c, { projectSlug, path: folder, operatorConsent }) => {
+        await checkTenantBoundary(projectSlug, "local repository");
+        const snapshot = await c.getProjectSnapshot(projectSlug);
+        const result = initLocalRepo(
+          new CheckoutRegistry(resolveStateDir()),
+          {
+            projectSlug,
+            path: folder,
+            operatorConsent,
+            project: { codeHost: snapshot.project.codeHost ?? null, githubRepo: snapshot.github?.repo ?? null }
+          },
+          import_node_os11.default.hostname()
+        );
+        if (!result.ok) {
+          const codeMap = {
+            not_absolute: "LOCAL_CHECKOUT_PATH_NOT_ABSOLUTE",
+            not_found: "LOCAL_CHECKOUT_PATH_NOT_FOUND",
+            not_a_directory: "LOCAL_CHECKOUT_PATH_NOT_FOUND",
+            not_owned: "LOCAL_CHECKOUT_PATH_FORBIDDEN",
+            forbidden_path: "LOCAL_CHECKOUT_PATH_FORBIDDEN",
+            path_changed: "LOCAL_CHECKOUT_PATH_FORBIDDEN",
+            not_a_git_repo: "LOCAL_CHECKOUT_NOT_A_GIT_REPO",
+            inside_git_repo: "LOCAL_REPO_ALREADY_EXISTS",
+            not_local_project: "LOCAL_CHECKOUT_REPO_REQUIRED",
+            consent_required: "LOCAL_REPO_CONSENT_REQUIRED",
+            init_failed: "LOCAL_REPO_INIT_FAILED"
+          };
+          throw new McpToolCodedError(codeMap[result.code], result.detail);
+        }
+        return result.data;
+      }
+    ),
+    [mcpToolNames.setProjectCodeHost]: makeTool(
+      client,
+      mcpToolNames.setProjectCodeHost,
+      "PROJECT_CODE_HOST_FAILED",
+      "Unable to record where the project's code lives.",
+      async (c, { projectSlug, codeHost }) => {
+        await checkTenantBoundary(projectSlug, "project code host");
+        return await c.renameProject(projectSlug, { codeHost });
+      }
+    ),
     [mcpToolNames.retrieveContext]: makeTool(
       client,
       mcpToolNames.retrieveContext,
@@ -61948,7 +62072,7 @@ Do NOT derail the current task - if the operator has an in-flight question, answ
 }
 
 // src/_generated/version.ts
-var PKG_VERSION = "0.4.117";
+var PKG_VERSION = "0.4.118";
 
 // src/receipt-signing.ts
 var import_node_crypto13 = __toESM(require("node:crypto"), 1);
@@ -66790,6 +66914,9 @@ ${renderTaskStateSection(taskState)}`;
       localGitMode = false;
     }
   }
+  if (claimed.codeExecution && localGitMode) {
+    await askCodeHostOnce(deps, projectSlug, task.id);
+  }
   if (claimed.codeExecution && localGitMode && !checkout) {
     await failRun(
       deps,
@@ -67871,6 +67998,27 @@ async function resetWedgedThread(deps, projectSlug, taskId, interruptFailed) {
   await deps.client.resetDirectorThread(projectSlug, taskId).catch(() => {
   });
 }
+function codeHostQuestionId(projectSlug) {
+  return `II-code-host-${projectSlug.replace(/[^A-Za-z0-9._-]/g, "-")}`;
+}
+async function askCodeHostOnce(deps, projectSlug, taskId) {
+  try {
+    const snapshot = await deps.client.getProjectSnapshot(projectSlug);
+    if (snapshot.project.codeHost != null) return;
+    await deps.client.createInboxItem(projectSlug, {
+      id: codeHostQuestionId(projectSlug),
+      kind: "question",
+      taskId,
+      body: "Your project's code is being saved on this computer, in your project folder. Should it stay only here, or would you also like a copy on GitHub or GitLab (useful for backups and teammates)?",
+      questionOptions: [
+        { label: "Keep it on this computer", answer: "local", description: "Nothing is uploaded anywhere.", recommended: true },
+        { label: "Also put it on GitHub", answer: "github", description: "You will be asked to connect GitHub." },
+        { label: "Also put it on GitLab", answer: "gitlab", description: "You will be asked to connect GitLab." }
+      ]
+    });
+  } catch {
+  }
+}
 async function deliverLocalRun(deps, input) {
   const { projectSlug, task, runId, leaseId } = input;
   if (!input.baseSha) {
@@ -74951,7 +75099,7 @@ function buildThreadStartParams(msg, config2, desiredModel) {
     "- Reply in the operator's language for the whole turn (questions, task scopes, summaries).",
     "- Keep chat short and human. No code blocks, DDL, terminal output, local filesystem paths, internal job/inbox UUIDs or alert markers in chat \u2014 put long content into a wiki page and link it.",
     "- Spec pages in folder Specs must contain `## Acceptance criteria` followed by `- [ ]` items.",
-    "- AGNOSTIC DELIVERY MANDATE: Mrrlin is an Agnostic Delivery Platform decoupled from mandatory GitHub. Delivery is routed strictly by artifact kind: (1) document -> wiki (specs, policies, legal compliance playbooks, project documentation); (2) page -> publish (web pages, landing pages, interactive HTML previews); (3) file_set -> artifacts (file uploads, bundles, build zips); (4) message -> send (outbound webhooks, Slack, notifications); (5) code_change -> repo_host (git / GitHub ONLY when modifying source repository code). NEVER stall or refuse non-code tasks (such as marketing landing pages, GDPR checklists, or legal compliance playbooks) by demanding a Git repository. Non-code tasks deliver directly via page (Publish) or document (Wiki).",
+    "- AGNOSTIC DELIVERY MANDATE: Mrrlin is an Agnostic Delivery Platform decoupled from mandatory GitHub. Delivery is routed strictly by artifact kind: (1) document -> wiki; (2) page -> publish (web pages, landing pages, interactive HTML previews); (3) file_set -> artifacts (file uploads, bundles, build zips); (4) message -> send (outbound webhooks, Slack, notifications); (5) code_change -> repo_host (GitHub; with no GitHub, a local git repo on the operator's computer: register_local_checkout without repo, init_local_repo only after an explicit yes, record their push choice with set_project_code_host). NEVER stall or refuse non-code tasks by demanding a Git repository. Non-code tasks deliver directly via page (Publish) or document (Wiki).",
     "- 3-TIER COMMERCIAL SCOPE GOVERNANCE: Treat tasks by domain governance tier. (1) Tier 1 Core Tech Delivery (backend, frontend, SRE, databases): decompose autonomously into repository code changes (when a repo is bound) or code artifacts. (2) Tier 2 Planning & Content (landing pages, SEO, marketing): create actionable drafts; when details such as a phone number, brand name or copy are missing, do not loop on questions \u2014 create the task, record `## Placeholders: [NEED_INPUT: <item>]` in the Wiki spec, and set `autonomyLevel: 'human_review'`. (3) Tier 3 Guardrailed Advisory (high risk: privacy/GDPR, security/SOC 2, billing, production database migrations, infrastructure): always set `autonomyLevel: 'human_review'`, put the domain's standard safety controls into the spec, and state that irreversible actions need human sign-off.",
     "- INBOX QUESTION RETIREMENT MANDATE \u2014 Retiring answered questions: Before creating a task/plan, retire only pending Inbox questions the operator actually answered. Call `decide_inbox_item(itemId: <exact id>, decidedBy: 'director', verdict: 'acknowledged', answer: <actual answer>)`. Use `verdict: 'rejected', reason: ...` only if moot. Never close an unrelated item.",
     "- CHAT CLARIFICATIONS ARE IN CHAT ONLY: During synchronous interactive Director chat, ask clarifying questions directly in your chat response. DO NOT call `create_inbox_item(kind: 'question')` for routine conversational clarifications in Turn 1 \u2014 Inbox questions are reserved for autonomous background workers or asynchronous gate pauses that occur while the operator is away.",
@@ -75439,7 +75587,7 @@ async function runCollectedAgentTurn(handle, prompt, cwd, baseInstructions) {
 }
 function resolveDefaultBranch(checkoutPath) {
   if (!checkoutPath) return "main";
-  const runGit = (args) => {
+  const runGit2 = (args) => {
     try {
       return (0, import_node_child_process25.execFileSync)("git", ["-C", checkoutPath, ...args], {
         encoding: "utf8",
@@ -75451,13 +75599,13 @@ function resolveDefaultBranch(checkoutPath) {
       return null;
     }
   };
-  const symRef = runGit(["symbolic-ref", "refs/remotes/origin/HEAD"]);
+  const symRef = runGit2(["symbolic-ref", "refs/remotes/origin/HEAD"]);
   if (symRef) {
     const prefix = "refs/remotes/origin/";
     const branch = symRef.startsWith(prefix) ? symRef.slice(prefix.length) : symRef;
     if (branch) return branch;
   }
-  const remoteShow = runGit(["remote", "show", "origin"]);
+  const remoteShow = runGit2(["remote", "show", "origin"]);
   if (remoteShow) {
     const match = /HEAD branch:\s*(\S+)/.exec(remoteShow);
     const branch = match?.[1];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrrlin-dev/mcp",
-  "version": "0.4.117",
+  "version": "0.4.118",
   "type": "module",
   "bin": {
     "mrrlin-mcp": "dist/bin.cjs"