@snappedly-tools/shipyard 0.8.0 → 0.9.1

package/dist/main.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
-import { CODEX_MODELS, purgeRunLogs, withFriendlyErrors, DEFAULT_LOG_RETENTION_DAYS, resolveEnv } from './chunk-JI3HDDMS.js';
-import { buildImage, removeImage, RunnerLifecycleError, removeRepositoryRunner, defaultImageName, validateExistingRepositoryRunner, RUNNER_INSTALL_METADATA, RUNNER_CONTROLLER_LOCK, recoverRepositoryRunner, REPOSITORY_RUNNER_OWNER_ENV, removeOwnedRepositoryRunnerContainers, RUNNER_WORK_DIR } from './chunk-44I2BL6E.js';
-import { SANDBOX_REPO_DIR, Display, InitError, ACTIVATION_LABEL, PRODUCT_NAME, CONFIG_DIR, CLI_NAME, ClackDisplay, ConfigDirError, ExecHostError, LOCKS_DIR, RUNNER_DIR, assertProtectedDirectoryIdentities, repositoryRunnerEnvironment } from './chunk-L6PX5QTU.js';
+import { CODEX_MODELS, purgeRunLogs, withFriendlyErrors, DEFAULT_LOG_RETENTION_DAYS, resolveEnv } from './chunk-HXSZM52J.js';
+import { buildImage, RunnerLifecycleError, removeRepositoryRunner, removeImage, defaultImageName, validateExistingRepositoryRunner, RUNNER_INSTALL_METADATA, RUNNER_CONTROLLER_LOCK, lockOwnsProcess, recoverRepositoryRunner, REPOSITORY_RUNNER_OWNER_ENV, removeOwnedRepositoryRunnerContainers, RUNNER_WORK_DIR } from './chunk-JZUBT4WG.js';
+import { SANDBOX_REPO_DIR, Display, InitError, ACTIVATION_LABEL, PRODUCT_NAME, CONFIG_DIR, CLI_NAME, RUNNER_DIR, ClackDisplay, ConfigDirError, ExecHostError, LOCKS_DIR, assertProtectedDirectoryIdentities, repositoryRunnerEnvironment } from './chunk-57EEKW3R.js';
 import { NodeContext, NodeRuntime, NodeFileSystem } from '@effect/platform-node';
 import { Effect, Layer, Option, Exit, Cause } from 'effect';
 import { Options, Command } from '@effect/cli';
@@ -14,7 +14,7 @@ import { FileSystem } from '@effect/platform';
 import { fileURLToPath } from 'url';
 import { hostname, homedir } from 'os';
 import { createHash } from 'crypto';
-import { chmod, lstat, realpath, rm, mkdir, writeFile, readFile, access } from 'fs/promises';
+import { chmod, rm, lstat, realpath, mkdir, writeFile, readFile, access } from 'fs/promises';
 import 'module';
 
 var configDirExists = (repoDir) => Effect.gen(function* () {
@@ -101,6 +101,12 @@ var LOCKFILES = [
   ["yarn.lock", "yarn"],
   ["package-lock.json", "npm"]
 ];
+var DEPENDENCY_COMMANDS = {
+  npm: { add: "install", remove: "uninstall" },
+  pnpm: { add: "add", remove: "remove" },
+  yarn: { add: "add", remove: "remove" },
+  bun: { add: "add", remove: "remove" }
+};
 var detectPackageManager = (repoDir) => Effect.gen(function* () {
   const fs = yield* FileSystem.FileSystem;
   const pkgPath = join(repoDir, "package.json");
@@ -124,18 +130,8 @@ var detectPackageManager = (repoDir) => Effect.gen(function* () {
   }
   return "npm";
 });
-var addDependencyCommand = (packageManager, pkg) => {
-  switch (packageManager) {
-    case "pnpm":
-      return `pnpm add ${pkg}`;
-    case "yarn":
-      return `yarn add ${pkg}`;
-    case "bun":
-      return `bun add ${pkg}`;
-    case "npm":
-      return `npm install ${pkg}`;
-  }
-};
+var addDependencyCommand = (packageManager, pkg) => `${packageManager} ${DEPENDENCY_COMMANDS[packageManager].add} ${pkg}`;
+var removeDependencyCommand = (packageManager, pkg) => `${packageManager} ${DEPENDENCY_COMMANDS[packageManager].remove} ${pkg}`;
 var hostHasDependency = (repoDir, pkg) => Effect.gen(function* () {
   const fs = yield* FileSystem.FileSystem;
   const pkgPath = join(repoDir, "package.json");
@@ -271,11 +267,9 @@ var ISSUE_TRACKER_REGISTRY = [
 # Required repository permissions: Contents, Issues, and Pull requests (Read and write); Metadata (Read)
 # Or leave blank and run: GH_TOKEN="$(gh auth token)" npx shipyard run
 GH_TOKEN=
-# GitHub repository (owner/repository)
-GH_REPO=`
+`
   }
 ];
-var listIssueTrackers = () => ISSUE_TRACKER_REGISTRY;
 var getIssueTracker = (name) => ISSUE_TRACKER_REGISTRY.find((b) => b.name === name);
 var getAgent = (name) => AGENT_REGISTRY.find((a) => a.name === name);
 var SANDBOX_PROVIDER_REGISTRY = [
@@ -295,7 +289,7 @@ function getNextStepsLines() {
     "2. If using a model subscription, sign in. For Codex:",
     `   codex --config 'cli_auth_credentials_store="file"' login`,
     "   test -f ~/.codex/auth.json",
-    `3. Start with \`npx ${CLI_NAME} runner start\` (if installed) or \`npx ${CLI_NAME} run\``
+    `3. If the runner installed successfully, start it with \`npx ${CLI_NAME} runner start\`; otherwise run \`npx ${CLI_NAME} run\`.`
   ];
 }
 function getTemplatesDir() {
@@ -358,8 +352,8 @@ var rewriteMainTs = (configDir, agent, model, modelExplicit, sandboxProvider, ma
   }
   if (agent.name === "codex" && codexAuth === "chatgpt") {
     content = content.replace(
-      /\bdocker\(\)/g,
-      `docker(${CODEX_CHATGPT_AUTH_OPTIONS})`
+      "const sandboxAuthOptions = {};",
+      `const sandboxAuthOptions = ${CODEX_CHATGPT_AUTH_OPTIONS};`
     );
   }
   content = content.replace(/\bdocker\b/g, sandboxProvider.name);
@@ -564,11 +558,6 @@ var ensureCodexChatGptAuth = (options) => {
     });
   }
 };
-var runEffectPromise = async (effect) => {
-  const exit = await Effect.runPromiseExit(effect);
-  if (Exit.isFailure(exit)) throw Cause.squash(exit.cause);
-  return exit.value;
-};
 var REPOSITORY_RUNNER_WORKFLOW_PATH = ".github/workflows/shipyard-wake.yml";
 var REPOSITORY_RUNNER_WAKE_EXECUTABLE = "shipyard-wake";
 var REPOSITORY_RUNNER_WORKFLOW = `name: Shipyard wake-up
@@ -1274,31 +1263,58 @@ var installRepositoryRunner = async (options, adapters = defaultAdapters) => {
 };
 
 // src/InitRepositoryRunner.ts
-var initializeRepositoryRunner = async (options) => {
-  let shouldInstall = options.requested;
-  if (shouldInstall === void 0) {
-    shouldInstall = options.interactive ? await options.confirm({
-      message: "Install a foreground repository runner for labelled GitHub issues?",
-      initialValue: true
-    }) : false;
-  }
-  if (!shouldInstall) return { status: "declined" };
-  try {
-    return { status: "installed", result: await options.install() };
-  } catch (error) {
-    return {
-      status: "failed",
-      message: error instanceof Error ? error.message : String(error)
-    };
-  }
-};
 var repositoryRunnerNextSteps = () => [
-  `First, commit and push ${REPOSITORY_RUNNER_WORKFLOW_PATH} to the repository's default branch`,
+  `Ensure ${REPOSITORY_RUNNER_WORKFLOW_PATH} is committed and pushed to the repository's default branch`,
   `Keep the foreground controller open with \`npx ${CLI_NAME} runner start\``,
   `Inspect it from another terminal with \`npx ${CLI_NAME} runner status\``,
   `Stop it with \`npx ${CLI_NAME} runner stop\``,
   `Unregister and delete its protected files with \`npx ${CLI_NAME} runner remove\``
 ];
+var errorText = (error) => {
+  if (error !== null && typeof error === "object" && "stderr" in error) {
+    const stderr = error.stderr;
+    if (typeof stderr === "string" || Buffer.isBuffer(stderr)) {
+      const text = stderr.toString().trim();
+      if (text) return text;
+    }
+  }
+  return error instanceof Error ? error.message : String(error);
+};
+var commitAndPushInitSetup = (repoDir) => {
+  const branch = execFileSync("git", ["branch", "--show-current"], {
+    cwd: repoDir,
+    encoding: "utf8"
+  }).trim();
+  if (!branch) {
+    throw new Error("Cannot push the Shipyard setup from a detached HEAD.");
+  }
+  const paths = [CONFIG_DIR];
+  if (existsSync(join(repoDir, REPOSITORY_RUNNER_WORKFLOW_PATH))) {
+    paths.push(REPOSITORY_RUNNER_WORKFLOW_PATH);
+  }
+  execFileSync("git", ["add", "--", ...paths], {
+    cwd: repoDir,
+    stdio: "ignore"
+  });
+  execFileSync(
+    "git",
+    ["commit", "--only", "-m", "Add Shipyard setup", "--", ...paths],
+    { cwd: repoDir, stdio: "pipe" }
+  );
+  const commit = execFileSync("git", ["rev-parse", "--short", "HEAD"], {
+    cwd: repoDir,
+    encoding: "utf8"
+  }).trim();
+  try {
+    execFileSync("git", ["push", "origin", `HEAD:refs/heads/${branch}`], {
+      cwd: repoDir,
+      stdio: "pipe"
+    });
+    return { branch, commit };
+  } catch (error) {
+    return { branch, commit, pushError: errorText(error) };
+  }
+};
 var execFileAsync2 = promisify(execFile);
 var CONTROLLER_STATE = ".shipyard-state.json";
 var LAST_FAILURE = ".shipyard-last-failure.json";
@@ -1657,7 +1673,6 @@ var stopChildBounded = async (child, pause) => {
     );
   }
 };
-var lockOwnsProcess = async (lock, adapters) => lock !== void 0 && Number.isInteger(lock.pid) && typeof lock.processStartedAt === "string" && lock.processStartedAt.length > 0 && adapters.isProcessRunning(lock.pid) && await adapters.processIdentity(lock.pid) === lock.processStartedAt;
 var bestEffort = async (operation) => {
   try {
     await operation();
@@ -2199,6 +2214,11 @@ var stopRepositoryRunner = async (options, adapters = defaultAdapters2) => {
   }
   return { pid: lock.pid };
 };
+var runEffectPromise = async (effect) => {
+  const exit = await Effect.runPromiseExit(effect);
+  if (Exit.isFailure(exit)) throw Cause.squash(exit.cause);
+  return exit.value;
+};
 
 // src/RepositoryRunnerCommands.ts
 var registrationTokenOption = Options.text("registration-token").pipe(
@@ -2367,7 +2387,78 @@ var runnerCommand = Command.make(
     purgeRunnerCommand
   ])
 );
-var VERSION = "0.8.0" ;
+var VERSION = "0.9.1" ;
+var SHIPYARD_PACKAGE_NAME = "@snappedly-tools/shipyard";
+var isMissingPath = (error) => error !== null && typeof error === "object" && "code" in error && error.code === "ENOENT";
+var lstatIfPresent = async (path) => {
+  try {
+    return await lstat(path);
+  } catch (error) {
+    if (isMissingPath(error)) return void 0;
+    throw error;
+  }
+};
+var inspectShipyardConfigDirectory = async (repoDir) => {
+  const configDir = join(repoDir, CONFIG_DIR);
+  const info = await lstatIfPresent(configDir);
+  if (!info) return false;
+  if (!info.isDirectory() || info.isSymbolicLink()) {
+    throw new Error(
+      `Refusing to uninstall because ${configDir} is not a real directory.`
+    );
+  }
+  return true;
+};
+var removeWakeWorkflow = async (repoDir) => {
+  const githubDir = join(repoDir, ".github");
+  const workflowsDir = join(githubDir, "workflows");
+  const workflowPath = join(repoDir, REPOSITORY_RUNNER_WORKFLOW_PATH);
+  const githubInfo = await lstatIfPresent(githubDir);
+  if (!githubInfo) return { removed: false, preserved: false };
+  if (!githubInfo.isDirectory() || githubInfo.isSymbolicLink()) {
+    return { removed: false, preserved: githubInfo.isSymbolicLink() };
+  }
+  const workflowsInfo = await lstatIfPresent(workflowsDir);
+  if (!workflowsInfo) return { removed: false, preserved: false };
+  if (!workflowsInfo.isDirectory() || workflowsInfo.isSymbolicLink()) {
+    return {
+      removed: false,
+      preserved: workflowsInfo.isSymbolicLink()
+    };
+  }
+  const workflowInfo = await lstatIfPresent(workflowPath);
+  if (!workflowInfo) return { removed: false, preserved: false };
+  if (!workflowInfo.isFile() || workflowInfo.isSymbolicLink()) {
+    return { removed: false, preserved: true };
+  }
+  const workflow = await readFile(workflowPath, "utf8");
+  if (workflow !== REPOSITORY_RUNNER_WORKFLOW) {
+    return { removed: false, preserved: true };
+  }
+  await rm(workflowPath);
+  return { removed: true, preserved: false };
+};
+var removeShipyardRepositoryFiles = async (options) => {
+  const configDirExists2 = await inspectShipyardConfigDirectory(options.repoDir);
+  if (configDirExists2) {
+    const configDir = join(options.repoDir, CONFIG_DIR);
+    const runnerDir = join(configDir, RUNNER_DIR);
+    if (await lstatIfPresent(runnerDir)) {
+      throw new Error(
+        `Remove the repository runner at ${runnerDir} before removing Shipyard configuration.`
+      );
+    }
+  }
+  const workflow = await removeWakeWorkflow(options.repoDir);
+  if (configDirExists2) {
+    await rm(join(options.repoDir, CONFIG_DIR), { recursive: true });
+  }
+  return {
+    workflowRemoved: workflow.removed,
+    workflowPreserved: workflow.preserved,
+    configDirectoryRemoved: configDirExists2
+  };
+};
 
 // src/cli.ts
 var imageNameOption = Options.text("image-name").pipe(
@@ -2383,7 +2474,6 @@ var defaultUidBuildArgs = () => {
   if (gid !== void 0) args.AGENT_GID = String(gid);
   return args;
 };
-var requireConfigDir = (cwd) => requireCanonicalConfigDir(cwd);
 var purgeRunLogsBestEffort = (display, repoDir) => Effect.tryPromise({
   try: () => purgeRunLogs({
     repoDir,
@@ -2503,7 +2593,7 @@ var runCommand2 = Command.make(
   ({ imageName: imageNameFlag, sandbox, skipBuild, entrypoint }) => Effect.gen(function* () {
     const d = yield* Display;
     const cwd = process.cwd();
-    const configDir = yield* requireConfigDir(cwd);
+    const configDir = yield* requireCanonicalConfigDir(cwd);
     yield* purgeRunLogsBestEffort(d, cwd);
     const resolvedEntrypoint = resolveRunEntrypoint(
       cwd,
@@ -2562,14 +2652,6 @@ var sandboxOption = Options.text("sandbox").pipe(
   Options.withDescription("Sandbox provider to use (docker)"),
   Options.optional
 );
-var issueTrackerOption = Options.text("issue-tracker").pipe(
-  Options.withDescription("Issue tracker to use (github-issues)"),
-  Options.optional
-);
-var buildImageOption = Options.choice("build-image", ["true", "false"]).pipe(
-  Options.withDescription("Whether to build the sandbox image now"),
-  Options.optional
-);
 var installTemplateDepsOption = Options.choice("install-template-deps", [
   "true",
   "false"
@@ -2579,14 +2661,18 @@ var installTemplateDepsOption = Options.choice("install-template-deps", [
   ),
   Options.optional
 );
-var installRunnerOption = Options.choice("install-runner", [
-  "true",
-  "false"
-]).pipe(
+var commitSetupOption = Options.choice("commit-setup", ["true", "false"]).pipe(
   Options.withDescription(
-    "Whether to install a foreground repository runner after scaffolding"
-  ),
-  Options.optional
+    "Whether to commit and push .shipyard/ and any generated runner workflow"
+  )
+).pipe(Options.optional);
+var uninstallYesOption = Options.boolean("yes").pipe(
+  Options.withDescription("confirm uninstall without an interactive prompt")
+);
+var uninstallForceOption = Options.boolean("force").pipe(
+  Options.withDescription(
+    "remove local runner files if GitHub unregistration fails"
+  )
 );
 var choiceToTriBool = (opt) => opt._tag === "Some" ? Option.some(opt.value === "true") : Option.none();
 var initCommand = Command.make(
@@ -2598,10 +2684,8 @@ var initCommand = Command.make(
     codexAuth: codexAuthOption,
     model: initModelOption,
     sandbox: sandboxOption,
-    issueTracker: issueTrackerOption,
-    buildImage: buildImageOption,
     installTemplateDeps: installTemplateDepsOption,
-    installRunner: installRunnerOption
+    commitSetup: commitSetupOption
   },
   ({
     imageName: imageNameFlag,
@@ -2610,10 +2694,8 @@ var initCommand = Command.make(
     codexAuth: codexAuthFlag,
     model: modelFlag,
     sandbox: sandboxFlag,
-    issueTracker: issueTrackerFlag,
-    buildImage: buildImageFlag,
     installTemplateDeps: installTemplateDepsFlag,
-    installRunner: installRunnerFlag
+    commitSetup: commitSetupFlag
   }) => Effect.gen(function* () {
     const d = yield* Display;
     const cwd = process.cwd();
@@ -2641,355 +2723,530 @@ var initCommand = Command.make(
         );
       }
     }
-    if (issueTrackerFlag._tag === "Some") {
-      const valid = getIssueTracker(issueTrackerFlag.value);
-      if (!valid) {
-        const names = listIssueTrackers().map((t) => t.name).join(", ");
-        yield* Effect.fail(
-          new InitError({
-            message: `Unknown issue tracker "${issueTrackerFlag.value}". Available: ${names}`
-          })
+    yield* d.progress(
+      "Initializing Shipyard",
+      (report) => Effect.gen(function* () {
+        const progressAt = (current, message) => report({ current, total: 100, message });
+        const progressRange = (start, end, update) => {
+          const total = Math.max(1, update.total);
+          const fraction = Math.min(1, Math.max(0, update.current / total));
+          progressAt(
+            Math.round(start + (end - start) * fraction),
+            update.message
+          );
+        };
+        const whilePrompt = async (prompt) => {
+          report.pause();
+          try {
+            return await prompt();
+          } finally {
+            report.resume();
+          }
+        };
+        const statusWithProgress = (message, severity) => Effect.acquireUseRelease(
+          Effect.sync(() => report.pause()),
+          () => d.status(message, severity),
+          () => Effect.sync(() => report.resume())
         );
-      }
-    }
-    const buildImageChoice = choiceToTriBool(buildImageFlag);
-    const installTemplateDepsChoice = choiceToTriBool(
-      installTemplateDepsFlag
-    );
-    const installRunnerChoice = choiceToTriBool(installRunnerFlag);
-    const isInteractive = process.stdin.isTTY === true;
-    const failIfNonInteractive = (flag) => Effect.fail(
-      new InitError({
-        message: `${flag} is required in non-interactive mode (no TTY detected).`
-      })
-    );
-    const resolveConfirmFlag = (params) => Effect.gen(function* () {
-      if (params.choice._tag === "Some") return params.choice.value;
-      if (!isInteractive) {
-        yield* failIfNonInteractive(params.flag);
-      }
-      const confirmed = yield* Effect.promise(
-        () => clack2.confirm({
-          message: params.promptMessage,
-          initialValue: true
-        })
-      );
-      if (clack2.isCancel(confirmed)) {
-        yield* Effect.fail(
-          new InitError({ message: params.cancelMessage })
+        const installTemplateDepsChoice = choiceToTriBool(
+          installTemplateDepsFlag
         );
-      }
-      return confirmed === true;
-    });
-    const agents = listAgents();
-    let selectedAgent;
-    if (agentFlag._tag === "Some") {
-      const entry = getAgent(agentFlag.value);
-      if (!entry) {
-        const names = agents.map((a) => a.name).join(", ");
-        yield* Effect.fail(
+        const commitSetupChoice = choiceToTriBool(commitSetupFlag);
+        const isInteractive = process.stdin.isTTY === true;
+        const failIfNonInteractive = (flag) => Effect.fail(
           new InitError({
-            message: `Unknown agent "${agentFlag.value}". Available: ${names}`
+            message: `${flag} is required in non-interactive mode (no TTY detected).`
           })
         );
-      }
-      selectedAgent = entry;
-    } else {
-      if (!isInteractive) {
-        yield* failIfNonInteractive("--agent");
-      }
-      const selected = yield* Effect.promise(
-        () => clack2.select({
-          message: "Select an agent:",
-          initialValue: DEFAULT_AGENT_NAME,
-          options: agents.map((a) => ({
-            value: a.name,
-            label: a.label,
-            hint: `Default model: ${a.defaultModel}`
-          }))
-        })
-      );
-      if (clack2.isCancel(selected)) {
-        yield* Effect.fail(
-          new InitError({ message: "Agent selection cancelled." })
-        );
-      }
-      selectedAgent = getAgent(selected);
-    }
-    const selectedCodexAuth = yield* Effect.tryPromise({
-      try: () => resolveCodexAuthMode({
-        agentName: selectedAgent.name,
-        requested: codexAuthFlag._tag === "Some" ? codexAuthFlag.value : void 0,
-        interactive: isInteractive,
-        select: async () => {
-          const selected = await clack2.select({
-            message: "How will you authenticate Codex?",
-            initialValue: "chatgpt",
-            options: [
-              {
-                value: "chatgpt",
-                label: "Sign in with ChatGPT",
-                hint: "Use your ChatGPT subscription"
-              },
-              {
-                value: "api-key",
-                label: "OpenAI API key",
-                hint: "Use API billing"
+        const resolveConfirmFlag = (params) => Effect.gen(function* () {
+          if (params.choice._tag === "Some") return params.choice.value;
+          if (!isInteractive) {
+            yield* failIfNonInteractive(params.flag);
+          }
+          const confirmed = yield* Effect.promise(
+            () => whilePrompt(
+              () => clack2.confirm({
+                message: params.promptMessage,
+                initialValue: true
+              })
+            )
+          );
+          if (clack2.isCancel(confirmed)) {
+            yield* Effect.fail(
+              new InitError({ message: params.cancelMessage })
+            );
+          }
+          return confirmed === true;
+        });
+        const agents = listAgents();
+        let selectedAgent;
+        if (agentFlag._tag === "Some") {
+          const entry = getAgent(agentFlag.value);
+          if (!entry) {
+            const names = agents.map((a) => a.name).join(", ");
+            yield* Effect.fail(
+              new InitError({
+                message: `Unknown agent "${agentFlag.value}". Available: ${names}`
+              })
+            );
+          }
+          selectedAgent = entry;
+        } else {
+          if (!isInteractive) {
+            yield* failIfNonInteractive("--agent");
+          }
+          const selected = yield* Effect.promise(
+            () => whilePrompt(
+              () => clack2.select({
+                message: "Select an agent:",
+                initialValue: DEFAULT_AGENT_NAME,
+                options: agents.map((a) => ({
+                  value: a.name,
+                  label: a.label,
+                  hint: `Default model: ${a.defaultModel}`
+                }))
+              })
+            )
+          );
+          if (clack2.isCancel(selected)) {
+            yield* Effect.fail(
+              new InitError({ message: "Agent selection cancelled." })
+            );
+          }
+          selectedAgent = getAgent(selected);
+        }
+        progressAt(6, `Selected ${selectedAgent.label}`);
+        const selectedCodexAuth = yield* Effect.tryPromise({
+          try: () => resolveCodexAuthMode({
+            agentName: selectedAgent.name,
+            requested: codexAuthFlag._tag === "Some" ? codexAuthFlag.value : void 0,
+            interactive: isInteractive,
+            select: async () => {
+              const selected = await whilePrompt(
+                () => clack2.select({
+                  message: "How will you authenticate Codex?",
+                  initialValue: "chatgpt",
+                  options: [
+                    {
+                      value: "chatgpt",
+                      label: "Sign in with ChatGPT",
+                      hint: "Use your ChatGPT subscription"
+                    },
+                    {
+                      value: "api-key",
+                      label: "OpenAI API key",
+                      hint: "Use API billing"
+                    }
+                  ]
+                })
+              );
+              return clack2.isCancel(selected) ? void 0 : selected;
+            }
+          }),
+          catch: (error) => error instanceof InitError ? error : new InitError({
+            message: `Codex authentication selection failed: ${String(error)}`
+          })
+        });
+        progressAt(12, "Authentication method selected");
+        const selectedModel = modelFlag._tag === "Some" ? modelFlag.value : selectedAgent.defaultModel;
+        if (selectedCodexAuth === "chatgpt") {
+          yield* Effect.try({
+            try: () => {
+              report.pause();
+              try {
+                ensureCodexChatGptAuth({
+                  cwd,
+                  interactive: isInteractive
+                });
+              } finally {
+                report.resume();
               }
-            ]
+            },
+            catch: (error) => error instanceof InitError ? error : new InitError({
+              message: `Codex authentication setup failed: ${String(error)}`
+            })
           });
-          return clack2.isCancel(selected) ? void 0 : selected;
         }
-      }),
-      catch: (error) => error instanceof InitError ? error : new InitError({
-        message: `Codex authentication selection failed: ${String(error)}`
-      })
-    });
-    const selectedModel = modelFlag._tag === "Some" ? modelFlag.value : selectedAgent.defaultModel;
-    if (selectedCodexAuth === "chatgpt") {
-      yield* Effect.try({
-        try: () => ensureCodexChatGptAuth({
-          cwd,
-          interactive: isInteractive
-        }),
-        catch: (error) => error instanceof InitError ? error : new InitError({
-          message: `Codex authentication setup failed: ${String(error)}`
-        })
-      });
-    }
-    const selectedSandboxProvider = getSandboxProvider("docker");
-    const issueTrackers = listIssueTrackers();
-    let selectedIssueTracker;
-    if (issueTrackerFlag._tag === "Some") {
-      selectedIssueTracker = getIssueTracker(issueTrackerFlag.value);
-    } else {
-      if (!isInteractive) {
-        yield* failIfNonInteractive("--issue-tracker");
-      }
-      const selected = yield* Effect.promise(
-        () => clack2.select({
-          message: "Select an issue tracker:",
-          initialValue: "github-issues",
-          options: issueTrackers.map((b) => ({
-            value: b.name,
-            label: b.label
-          }))
-        })
-      );
-      if (clack2.isCancel(selected)) {
-        yield* Effect.fail(
-          new InitError({
-            message: "Issue tracker selection cancelled."
-          })
-        );
-      }
-      selectedIssueTracker = getIssueTracker(selected);
-    }
-    let selectedTemplate;
-    if (template._tag === "Some") {
-      selectedTemplate = template.value;
-    } else {
-      if (!isInteractive) {
-        yield* failIfNonInteractive("--template");
-      }
-      const selected = yield* Effect.promise(
-        () => clack2.select({
-          message: "Select a template:",
-          initialValue: "simple-loop",
-          options: templates.map((tmpl) => ({
-            value: tmpl.name,
-            label: tmpl.name,
-            hint: tmpl.description
-          }))
-        })
-      );
-      if (clack2.isCancel(selected)) {
-        yield* Effect.fail(
-          new InitError({ message: "Template selection cancelled." })
-        );
-      }
-      selectedTemplate = selected;
-    }
-    if (selectedIssueTracker.name === "github-issues") {
-      const failedLabels = [];
-      for (const [name, description, color] of [
-        [ACTIVATION_LABEL, `Issues for ${PRODUCT_NAME} to work on`, "F9A825"],
-        ["bug", "Something is broken", "D73A4A"],
-        ["enhancement", "New feature or improvement", "A2EEEF"],
-        ["needs-triage", "Maintainer evaluation needed", "FBCA04"],
-        ["needs-info", "Waiting for reporter information", "D4C5F9"],
-        ["ready-for-agent", "Ready for agent implementation", "0E8A16"],
-        ["ready-for-human", "Requires human implementation", "1D76DB"],
-        ["wontfix", "Will not be actioned", "FFFFFF"],
-        ["shipyard:blocked", "Shipyard work needs intervention", "B60205"],
-        ["shipyard:pending", "Shipyard is working on this ticket", "1D76DB"],
-        [
-          "shipyard:complete",
-          "Shipyard work ready for human review",
-          "0E8A16"
-        ],
-        [
-          "shipyard:outstanding-tasks",
-          "Spec has uncompleted tickets",
-          "FBCA04"
-        ]
-      ]) {
-        try {
-          execSync(
-            `gh label create "${name}" --description "${description}" --color "${color}" --force`,
-            { cwd, stdio: "ignore" }
+        progressAt(18, "Authentication setup complete");
+        const selectedSandboxProvider = getSandboxProvider("docker");
+        const selectedIssueTracker = getIssueTracker("github-issues");
+        let selectedTemplate;
+        if (template._tag === "Some") {
+          selectedTemplate = template.value;
+        } else {
+          if (!isInteractive) {
+            yield* failIfNonInteractive("--template");
+          }
+          const selected = yield* Effect.promise(
+            () => whilePrompt(
+              () => clack2.select({
+                message: "Select a template:",
+                initialValue: "simple-loop",
+                options: templates.map((tmpl) => ({
+                  value: tmpl.name,
+                  label: tmpl.name,
+                  hint: tmpl.description
+                }))
+              })
+            )
           );
-        } catch {
-          failedLabels.push(name);
+          if (clack2.isCancel(selected)) {
+            yield* Effect.fail(
+              new InitError({ message: "Template selection cancelled." })
+            );
+          }
+          selectedTemplate = selected;
         }
-      }
-      if (failedLabels.length) {
-        let connected = Boolean(process.env.GH_REPO);
-        try {
-          execSync("git remote get-url origin", { cwd, stdio: "ignore" });
-          connected = true;
-        } catch {
+        progressAt(24, `Selected ${selectedTemplate} template`);
+        const failedLabels = [];
+        const labels = [
+          [
+            ACTIVATION_LABEL,
+            `Issues for ${PRODUCT_NAME} to work on`,
+            "F9A825"
+          ],
+          ["bug", "Something is broken", "D73A4A"],
+          ["enhancement", "New feature or improvement", "A2EEEF"],
+          ["needs-triage", "Maintainer evaluation needed", "FBCA04"],
+          ["needs-info", "Waiting for reporter information", "D4C5F9"],
+          ["ready-for-agent", "Ready for agent implementation", "0E8A16"],
+          ["ready-for-human", "Requires human implementation", "1D76DB"],
+          ["wontfix", "Will not be actioned", "FFFFFF"],
+          ["shipyard:blocked", "Shipyard work needs intervention", "B60205"],
+          [
+            "shipyard:pending",
+            "Shipyard is working on this ticket",
+            "1D76DB"
+          ],
+          [
+            "shipyard:complete",
+            "Shipyard work ready for human review",
+            "0E8A16"
+          ],
+          [
+            "shipyard:outstanding-tasks",
+            "Spec has uncompleted tickets",
+            "FBCA04"
+          ]
+        ];
+        for (const [index, [name, description, color]] of labels.entries()) {
+          try {
+            execSync(
+              `gh label create "${name}" --description "${description}" --color "${color}" --force`,
+              { cwd, stdio: "ignore" }
+            );
+          } catch {
+            failedLabels.push(name);
+          }
+          progressAt(
+            24 + Math.round((index + 1) / labels.length * 10),
+            "Provisioning GitHub labels"
+          );
         }
-        const message = `Could not create GitHub labels: ${failedLabels.join(", ")}. Check GitHub access and rerun init.`;
-        if (connected) yield* Effect.fail(new InitError({ message }));
-        console.warn(message);
-      }
-    }
-    yield* d.progress(
-      `Scaffolding ${CONFIG_DIR}/ config directory...`,
-      (report) => scaffold(cwd, {
-        agent: selectedAgent,
-        model: selectedModel,
-        modelExplicit: modelFlag._tag === "Some",
-        templateName: selectedTemplate,
-        issueTracker: selectedIssueTracker,
-        sandboxProvider: selectedSandboxProvider,
-        codexAuth: selectedCodexAuth,
-        onProgress: report
-      }).pipe(
-        Effect.mapError(
-          (e) => new InitError({
-            message: `${e instanceof Error ? e.message : e}`
+        if (failedLabels.length) {
+          let connected = Boolean(process.env.GH_REPO);
+          try {
+            execSync("git remote get-url origin", { cwd, stdio: "ignore" });
+            connected = true;
+          } catch {
+          }
+          const message = `Could not create GitHub labels: ${failedLabels.join(", ")}. Check GitHub access and rerun init.`;
+          if (connected) yield* Effect.fail(new InitError({ message }));
+          report.pause();
+          try {
+            console.warn(message);
+          } finally {
+            report.resume();
+          }
+        }
+        progressAt(34, `Scaffolding ${CONFIG_DIR}/ config directory`);
+        yield* scaffold(cwd, {
+          agent: selectedAgent,
+          model: selectedModel,
+          modelExplicit: modelFlag._tag === "Some",
+          templateName: selectedTemplate,
+          issueTracker: selectedIssueTracker,
+          sandboxProvider: selectedSandboxProvider,
+          codexAuth: selectedCodexAuth,
+          onProgress: (update) => progressRange(34, 56, update)
+        }).pipe(
+          Effect.mapError(
+            (e) => new InitError({
+              message: `${e instanceof Error ? e.message : e}`
+            })
+          )
+        );
+        progressAt(56, "Shipyard configuration generated");
+        const packageManager = yield* detectPackageManager(cwd);
+        progressAt(58, `Detected ${packageManager}`);
+        if (getTemplateDependencies(selectedTemplate).includes("zod")) {
+          const alreadyInstalled = yield* hostHasDependency(cwd, "zod");
+          if (!alreadyInstalled) {
+            const installCmd = addDependencyCommand(packageManager, "zod");
+            const shouldInstall = yield* resolveConfirmFlag({
+              choice: installTemplateDepsChoice,
+              flag: "--install-template-deps",
+              promptMessage: `The ${selectedTemplate} template needs a schema validator. Install zod now (\`${installCmd}\`)?`,
+              cancelMessage: "Install-template-deps selection cancelled."
+            });
+            progressAt(
+              60,
+              shouldInstall ? "Installing template dependency" : "Skipping zod installation"
+            );
+            if (shouldInstall) {
+              progressAt(62, `Installing zod with ${packageManager}`);
+              const installed = yield* Effect.sync(() => {
+                try {
+                  execSync(installCmd, { cwd, stdio: "ignore" });
+                  return true;
+                } catch {
+                  return false;
+                }
+              });
+              progressAt(64, "Template dependency setup complete");
+              yield* installed ? statusWithProgress(
+                `Installed zod with ${packageManager}.`,
+                "success"
+              ) : statusWithProgress(
+                `Couldn't install zod automatically. Run \`${installCmd}\` before running the agent.`,
+                "warn"
+              );
+            }
+          }
+        }
+        progressAt(66, "Template dependencies ready");
+        const providerLabel = selectedSandboxProvider.label;
+        const containerfileDir = join(cwd, CONFIG_DIR);
+        progressAt(68, `Building ${providerLabel} image '${imageName}'`);
+        yield* buildImage(imageName, containerfileDir, {
+          buildArgs: defaultUidBuildArgs()
+        });
+        progressAt(78, "Docker image built");
+        yield* statusWithProgress("Image built successfully.", "success");
+        progressAt(78, "Installing repository runner");
+        const runner = yield* Effect.tryPromise({
+          try: () => installRepositoryRunnerWithReplacement({
+            repoDir: cwd,
+            interactive: isInteractive,
+            confirmReplacement: async (conflict) => {
+              const confirmed = await whilePrompt(
+                () => clack2.confirm({
+                  message: conflict.confirmationMessage,
+                  initialValue: false
+                })
+              );
+              return !clack2.isCancel(confirmed) && confirmed === true;
+            },
+            install: () => installRepositoryRunner({
+              repoDir: cwd,
+              onProgress: (update) => progressRange(78, 94, update)
+            })
+          }),
+          catch: (error) => error instanceof InitError ? error : new InitError({
+            message: `Repository runner installation failed: ${error instanceof Error ? error.message : String(error)}. Init is incomplete. Fix the issue and retry with \`npx ${CLI_NAME} runner install\`.`
           })
-        )
-      )
-    );
-    const packageManager = yield* detectPackageManager(cwd);
-    if (getTemplateDependencies(selectedTemplate).includes("zod")) {
-      const alreadyInstalled = yield* hostHasDependency(cwd, "zod");
-      if (!alreadyInstalled) {
-        const installCmd = addDependencyCommand(packageManager, "zod");
-        const shouldInstall = yield* resolveConfirmFlag({
-          choice: installTemplateDepsChoice,
-          flag: "--install-template-deps",
-          promptMessage: `The ${selectedTemplate} template needs a schema validator. Install zod now (\`${installCmd}\`)?`,
-          cancelMessage: "Install-template-deps selection cancelled."
         });
-        if (shouldInstall) {
-          const installed = yield* Effect.sync(() => {
+        progressAt(94, "Repository runner installed");
+        yield* statusWithProgress(
+          `Installed ${runner.name} for ${runner.repository}.`,
+          "success"
+        );
+        let shouldCommitSetup = commitSetupChoice._tag === "Some" && commitSetupChoice.value;
+        if (commitSetupChoice._tag === "None" && isInteractive) {
+          const confirmed = yield* Effect.promise(
+            () => whilePrompt(
+              () => clack2.confirm({
+                message: "Commit .shipyard/ and any generated runner workflow, then push this branch to origin? Sandboxes need the setup committed. The push also sends any local commits not already on origin.",
+                initialValue: true
+              })
+            )
+          );
+          if (clack2.isCancel(confirmed)) {
+            yield* Effect.fail(
+              new InitError({
+                message: "Shipyard setup commit cancelled."
+              })
+            );
+          }
+          shouldCommitSetup = confirmed === true;
+        }
+        progressAt(
+          96,
+          shouldCommitSetup ? "Committing and pushing Shipyard setup" : "Setup commit skipped"
+        );
+        if (shouldCommitSetup) {
+          const publishResult = yield* Effect.sync(() => {
             try {
-              execSync(installCmd, { cwd, stdio: "ignore" });
-              return true;
-            } catch {
-              return false;
+              return {
+                status: "committed",
+                result: commitAndPushInitSetup(cwd)
+              };
+            } catch (error) {
+              return {
+                status: "failed",
+                message: error instanceof Error ? error.message : String(error)
+              };
             }
           });
-          yield* installed ? d.status(`Installed zod with ${packageManager}.`, "success") : d.status(
-            `Couldn't install zod automatically. Run \`${installCmd}\` before running the agent.`,
+          progressAt(99, "Shipyard setup commit finished");
+          if (publishResult.status === "failed") {
+            yield* statusWithProgress(
+              `Could not commit the Shipyard setup: ${publishResult.message}`,
+              "warn"
+            );
+            yield* statusWithProgress(
+              `Commit \`${CONFIG_DIR}/\` before running Shipyard.`,
+              "warn"
+            );
+          } else if (publishResult.result.pushError) {
+            yield* statusWithProgress(
+              `Committed ${publishResult.result.commit}, but could not push to origin/${publishResult.result.branch}: ${publishResult.result.pushError}`,
+              "warn"
+            );
+            yield* statusWithProgress(
+              `Push it later with \`git push origin ${publishResult.result.branch}\`.`,
+              "warn"
+            );
+          } else {
+            yield* statusWithProgress(
+              `Committed ${publishResult.result.commit} and pushed origin/${publishResult.result.branch}.`,
+              "success"
+            );
+          }
+        } else {
+          yield* statusWithProgress(
+            `Commit \`${CONFIG_DIR}/\` before running Shipyard. Sandboxes do not receive uncommitted setup files.`,
+            "warn"
+          );
+          yield* statusWithProgress(
+            "Push the runner wake workflow to the repository's default branch before starting the runner.",
             "warn"
           );
         }
-      }
+        progressAt(100, "Initialization complete");
+      })
+    );
+    yield* d.text("Repository runner next steps:");
+    for (const [index, line] of repositoryRunnerNextSteps().entries()) {
+      yield* d.text(styleText("dim", `${index + 1}. ${line}`));
+    }
+    yield* d.status("Init complete!", "success");
+    const nextSteps = getNextStepsLines();
+    for (const [i, line] of nextSteps.entries()) {
+      yield* d.text(i === 0 ? line : styleText("dim", line));
     }
-    const providerLabel = selectedSandboxProvider.label;
-    const shouldBuild = yield* resolveConfirmFlag({
-      choice: buildImageChoice,
-      flag: "--build-image",
-      promptMessage: `Build the default ${providerLabel} image now?`,
-      cancelMessage: "Build-image selection cancelled."
+  })
+);
+var uninstallCommand = Command.make(
+  "uninstall",
+  { yes: uninstallYesOption, force: uninstallForceOption },
+  ({ yes, force }) => Effect.gen(function* () {
+    const d = yield* Display;
+    const repoDir = process.cwd();
+    const configDirExists2 = yield* Effect.tryPromise({
+      try: () => inspectShipyardConfigDirectory(repoDir),
+      catch: (error) => new InitError({
+        message: `Could not inspect Shipyard configuration: ${error instanceof Error ? error.message : String(error)}`
+      })
     });
-    if (shouldBuild) {
-      const containerfileDir = join(cwd, CONFIG_DIR);
-      yield* d.spinner(
-        `Building ${providerLabel} image '${imageName}'...`,
-        buildImage(imageName, containerfileDir, {
-          buildArgs: defaultUidBuildArgs()
-        })
-      );
-      yield* d.status("Image built successfully.", "success");
-    } else {
+    const runnerDir = join(repoDir, CONFIG_DIR, RUNNER_DIR);
+    const runnerInstalled = configDirExists2 && existsSync(runnerDir);
+    const workflowExists = existsSync(
+      join(repoDir, REPOSITORY_RUNNER_WORKFLOW_PATH)
+    );
+    const packageInstalled = yield* hostHasDependency(
+      repoDir,
+      SHIPYARD_PACKAGE_NAME
+    );
+    if (!configDirExists2 && !workflowExists && !runnerInstalled && !packageInstalled) {
       yield* d.status(
-        `Run \`${CLI_NAME} ${selectedSandboxProvider.cliNamespace} build-image\` to build the ${providerLabel} image later.`,
+        "No Shipyard installation found in this repository.",
         "info"
       );
+      return;
     }
-    const runnerInit = yield* Effect.tryPromise({
-      try: () => initializeRepositoryRunner({
-        interactive: isInteractive,
-        requested: installRunnerChoice._tag === "Some" ? installRunnerChoice.value : void 0,
-        confirm: async ({ message, initialValue }) => {
-          const confirmed = await clack2.confirm({ message, initialValue });
-          if (clack2.isCancel(confirmed)) {
-            throw new InitError({
-              message: "Repository-runner installation selection cancelled."
-            });
-          }
-          return confirmed === true;
-        },
-        install: () => installRepositoryRunnerWithReplacement({
-          repoDir: cwd,
-          interactive: isInteractive,
-          confirmReplacement: async (conflict) => {
-            const confirmed = await clack2.confirm({
-              message: conflict.confirmationMessage,
-              initialValue: false
-            });
-            return !clack2.isCancel(confirmed) && confirmed === true;
-          },
-          install: () => runEffectPromise(
-            d.progress(
-              "Installing repository runner",
-              (report) => Effect.tryPromise({
-                try: () => installRepositoryRunner({
-                  repoDir: cwd,
-                  onProgress: report
-                }),
-                catch: (error) => error instanceof RunnerInstallError ? error : new InitError({
-                  message: `Repository runner installation failed: ${error instanceof Error ? error.message : String(error)}`
-                })
-              })
-            )
-          )
+    if (!yes && process.stdin.isTTY !== true) {
+      return yield* Effect.fail(
+        new InitError({
+          message: "Shipyard uninstall needs confirmation. Run it in a terminal or pass --yes."
         })
-      }),
-      catch: (error) => error instanceof InitError ? error : new InitError({
-        message: `Repository-runner setup failed: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+    if (!yes) {
+      const actions = [
+        runnerInstalled ? "unregister and remove the repository runner" : null,
+        configDirExists2 ? `remove all of ${CONFIG_DIR}/, including .env and runtime data` : null,
+        workflowExists ? "remove the generated runner wake workflow" : null,
+        packageInstalled ? `remove ${SHIPYARD_PACKAGE_NAME} from package.json` : null
+      ].filter((action) => action !== null);
+      const confirmation = yield* Effect.tryPromise({
+        try: () => clack2.confirm({
+          message: `Uninstall Shipyard from ${repoDir}? This will ${actions.join(", ")}. It leaves GitHub issues and labels unchanged.`,
+          initialValue: false
+        }),
+        catch: (error) => new InitError({
+          message: `Could not confirm Shipyard uninstall: ${error instanceof Error ? error.message : String(error)}`
+        })
+      });
+      if (clack2.isCancel(confirmation) || confirmation !== true) {
+        yield* d.status("Shipyard uninstall cancelled.", "info");
+        return;
+      }
+    }
+    if (runnerInstalled) {
+      const result = yield* Effect.tryPromise({
+        try: () => removeRepositoryRunner({ repoDir, force }),
+        catch: (error) => error instanceof RunnerLifecycleError ? new InitError({ message: error.message }) : new InitError({
+          message: `Repository runner removal failed: ${error instanceof Error ? error.message : String(error)}`
+        })
+      });
+      yield* d.status("Repository runner removed.", "success");
+      if (result.manualCleanup) {
+        yield* d.status(result.manualCleanup, "warn");
+      }
+    }
+    const files = yield* Effect.tryPromise({
+      try: () => removeShipyardRepositoryFiles({ repoDir }),
+      catch: (error) => new InitError({
+        message: `Could not remove Shipyard repository files: ${error instanceof Error ? error.message : String(error)}`
       })
     });
-    if (runnerInit.status === "installed") {
+    if (files.configDirectoryRemoved) {
+      yield* d.status(`Removed all of ${CONFIG_DIR}/.`, "success");
+    }
+    if (files.workflowRemoved) {
       yield* d.status(
-        `Installed ${runnerInit.result.name} for ${runnerInit.result.repository}.`,
+        `Removed ${REPOSITORY_RUNNER_WORKFLOW_PATH}.`,
         "success"
       );
-      yield* d.text("Repository runner next steps:");
-      for (const [index, line] of repositoryRunnerNextSteps().entries()) {
-        yield* d.text(styleText("dim", `${index + 1}. ${line}`));
-      }
-    } else if (runnerInit.status === "failed") {
       yield* d.status(
-        `Shipyard scaffolding is ready, but repository runner installation failed: ${runnerInit.message}`,
-        "warn"
+        "Commit and push the workflow deletion to disable it on GitHub.",
+        "info"
       );
+    } else if (files.workflowPreserved) {
       yield* d.status(
-        `Retry from this repository with \`npx ${CLI_NAME} runner install\`.`,
+        `Preserved ${REPOSITORY_RUNNER_WORKFLOW_PATH} because it is customized or linked.`,
         "warn"
       );
     }
-    yield* d.status("Init complete!", "success");
-    const nextSteps = getNextStepsLines();
-    for (const [i, line] of nextSteps.entries()) {
-      yield* d.text(i === 0 ? line : styleText("dim", line));
+    if (packageInstalled) {
+      const packageManager = yield* detectPackageManager(repoDir);
+      const command = removeDependencyCommand(
+        packageManager,
+        SHIPYARD_PACKAGE_NAME
+      );
+      yield* Effect.try({
+        try: () => execSync(command, { cwd: repoDir, stdio: "inherit" }),
+        catch: (error) => new InitError({
+          message: `Could not remove ${SHIPYARD_PACKAGE_NAME}. Rerun the uninstall after resolving the package-manager error: ${error instanceof Error ? error.message : String(error)}`
+        })
+      });
+      yield* d.status(
+        `Removed ${SHIPYARD_PACKAGE_NAME} with ${packageManager}.`,
+        "success"
+      );
     }
+    yield* d.status("Shipyard uninstalled from this repository.", "success");
   })
 );
 var dockerfileOption = Options.file("dockerfile").pipe(
@@ -3007,7 +3264,7 @@ var buildImageCommand = Command.make(
   ({ imageName: imageNameFlag, dockerfile }) => Effect.gen(function* () {
     const d = yield* Display;
     const cwd = process.cwd();
-    yield* requireConfigDir(cwd);
+    yield* requireCanonicalConfigDir(cwd);
     const imageName = resolveImageName(imageNameFlag, cwd);
     const dockerfileDir = join(cwd, CONFIG_DIR);
     const dockerfilePath = dockerfile._tag === "Some" ? dockerfile.value : void 0;
@@ -3060,6 +3317,7 @@ var rootCommand = Command.make(
 var shipyard = rootCommand.pipe(
   Command.withSubcommands([
     initCommand,
+    uninstallCommand,
     runCommand2,
     dockerCommand,
     runnerCommand