@outerlayer/cli 0.5.1 → 0.7.0

package/dist/chunk-HKMPVPO7.js

@@ -0,0 +1,55 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+
+createRequire(import.meta.url);
+
+// src/runner/commit-identity.ts
+var NOREPLY_SUFFIX = "@users.noreply.github.com";
+var MAX_LENGTH = 200;
+function parseIdentity(value) {
+  if (typeof value !== "object" || value === null) return void 0;
+  const { name, email } = value;
+  if (typeof name !== "string" || typeof email !== "string") return void 0;
+  if (name.trim() === "" || name.length > MAX_LENGTH || /[\r\n\0<>]/.test(name)) return void 0;
+  if (email.length > MAX_LENGTH || !email.endsWith(NOREPLY_SUFFIX) || /[\s\0<>]/.test(email) || email.length === NOREPLY_SUFFIX.length) return void 0;
+  return { name, email };
+}
+function parseClaimIdentity(data) {
+  const author = parseIdentity(data.commitAuthor);
+  if (author === void 0) return void 0;
+  const coAuthor = parseIdentity(data.coAuthor);
+  return coAuthor === void 0 ? { author } : { author, coAuthor };
+}
+function authorEnvironment(identity) {
+  if (identity === void 0) return {};
+  return {
+    GIT_AUTHOR_NAME: identity.name,
+    GIT_AUTHOR_EMAIL: identity.email,
+    GIT_COMMITTER_NAME: identity.name,
+    GIT_COMMITTER_EMAIL: identity.email
+  };
+}
+function configCount(env) {
+  const raw = String(env.GIT_CONFIG_COUNT);
+  return /^[0-9]+$/.test(raw) ? Number(raw) : 0;
+}
+function withGitConfig(env, key, value) {
+  const at = configCount(env);
+  return {
+    ...env,
+    GIT_CONFIG_COUNT: String(at + 1),
+    [`GIT_CONFIG_KEY_${at}`]: key,
+    [`GIT_CONFIG_VALUE_${at}`]: value
+  };
+}
+function withHooksPath(env, dir) {
+  return withGitConfig(env, "core.hooksPath", dir);
+}
+function commitIdentityRecord(identity) {
+  return {
+    author: identity === void 0 ? "host" : "app",
+    coAuthor: identity?.coAuthor !== void 0 && identity.hooksPath !== void 0 ? "credited" : "none"
+  };
+}
+
+export { authorEnvironment, commitIdentityRecord, parseClaimIdentity, withGitConfig, withHooksPath };

package/dist/{chunk-UFFXNXLQ.js → chunk-JPR2WHHF.js}

@@ -3,7 +3,7 @@ import { createRequire } from 'node:module';
 import { deadHooksState, huskyPrepareScript, preparePackageManagerCommand } from './chunk-XCCLFVXM.js';
 import { readRepoConnection, findGitDirs } from './chunk-BJ3KTMDH.js';
 import { homeFromEnv } from './chunk-VNVZDWO3.js';
-import { readFileSync, mkdirSync, writeFileSync, renameSync, existsSync, statSync, appendFileSync, openSync, opendirSync, unlinkSync } from 'fs';
+import { readFileSync, mkdirSync, writeFileSync, renameSync, existsSync, statSync, appendFileSync, opendirSync, unlinkSync } from 'fs';
 import { spawn, execFileSync } from 'child_process';
 import { createHash } from 'crypto';
 import { join, dirname, resolve } from 'path';
@@ -347,18 +347,11 @@ var readStdin = () => {
   }
 };
 var AUTO_SYNC_DEBOUNCE_MS = 5 * 60 * 1e3;
-function appendFd(path) {
-  if (path === void 0) return "ignore";
-  try {
-    return openSync(path, "a");
-  } catch {
-    return "ignore";
-  }
-}
-var spawnDetached = (command, args, stderrPath, cwd) => {
+var LOG_FAILURES_FLAG = "--log-failures";
+var spawnDetached = (command, args, cwd) => {
   const child = spawn(command, args, {
     detached: true,
-    stdio: ["ignore", "ignore", appendFd(stderrPath)],
+    stdio: ["ignore", "ignore", "ignore"],
     ...cwd !== void 0 ? { cwd } : {}
   });
   child.on("error", () => {
@@ -382,7 +375,7 @@ function maybeAutoSync(event, home = homeFromEnv(), spawnImpl = spawnDetached, n
       if (!config.appId) return;
     } else if (!config.accountToken || readRepoConnection(cwd) === void 0) return;
     writeFileSync(marker, String(now));
-    spawnImpl(process.execPath, [process.argv[1], "sync", "--quiet"], void 0, cwd);
+    spawnImpl(process.execPath, [process.argv[1], "sync", "--quiet"], cwd);
   } catch {
   }
 }
@@ -395,13 +388,13 @@ function hookErrorsContext(home, writtenBytes, seenBytes) {
 }
 async function handleWorkLaunch(sessionId, home, env, spawnImpl = spawnDetached, cwd = process.cwd()) {
   if (!sessionId || env.OUTERLAYER_WORK === void 0) return void 0;
-  const { parseWorkItemEnv, appendLaunchRecord } = await import('./work-launch-YI4CJDAP.js');
+  const { parseWorkItemEnv, appendLaunchRecord } = await import('./work-launch-R5HTAP6X.js');
   const parsed = parseWorkItemEnv(env.OUTERLAYER_WORK);
   if ("reason" in parsed) {
     logHookError(home, new Error(`OUTERLAYER_WORK ignored: ${parsed.reason}`));
     return `OuterLayer ignored this session's OUTERLAYER_WORK value: ${sanitizeForContext(parsed.reason)}. The session is not attached to a work item and will not upload. Hook failures are logged to ${join(spoolDir(home), "hook-errors.log")}.`;
   }
-  appendLaunchRecord({ sessionId, item: parsed.number }, home);
+  appendLaunchRecord({ sessionId, item: parsed.number, ...env.OUTERLAYER_JOB_DIR === void 0 ? {} : { job: env.OUTERLAYER_JOB_DIR } }, home);
   const args = [
     process.argv[1],
     "work",
@@ -417,17 +410,16 @@ async function handleWorkLaunch(sessionId, home, env, spawnImpl = spawnDetached,
     // hook has already returned) and cannot double-link, because the
     // link is keyed by the session id passed above.
     "--retry",
-    String(WORK_LINK_RETRIES)
+    String(WORK_LINK_RETRIES),
+    LOG_FAILURES_FLAG
   ];
   if (env.OUTERLAYER_JOB_DIR !== void 0) args.push("--no-lease");
   spawnImpl(
     process.execPath,
     args,
-    // The link runs after this hook has exited, so its own failure
-    // (offline, revoked key, unknown item number) has nowhere else to be
-    // seen: without this the session uploads later with no Work link and
-    // no trace of why.
-    join(spoolDir(home), "hook-errors.log"),
+    // The link appends its own failure line to hook-errors.log (see
+    // `--log-failures`), so a Node warning on a link that worked never
+    // reaches the log.
     cwd
   );
   return void 0;
@@ -456,30 +448,28 @@ async function maybeRenewWorkLease(event, sessionId, home = homeFromEnv(), env =
       if (now - statSync(marker).mtimeMs < WORK_LEASE_RENEW_DEBOUNCE_MS) return;
     } catch {
     }
-    const { parseWorkItemEnv } = await import('./work-launch-YI4CJDAP.js');
+    const { parseWorkItemEnv } = await import('./work-launch-R5HTAP6X.js');
     const parsed = parseWorkItemEnv(env.OUTERLAYER_WORK);
     if ("reason" in parsed) return;
     writeFileSync(marker, String(now));
     spawnImpl(
       process.execPath,
-      [process.argv[1], "work", "link-session", String(parsed.number), "--session-id", sessionId],
-      join(spoolDir(home), "hook-errors.log"),
+      [process.argv[1], "work", "link-session", String(parsed.number), "--session-id", sessionId, LOG_FAILURES_FLAG],
       cwd
     );
   } catch {
   }
 }
-async function handleWorkSessionEnd(event, sessionId, home = homeFromEnv(), env = process.env, spawnImpl = spawnDetached, cwd = process.cwd()) {
+async function handleWorkSessionEnd(event, sessionId, _home = homeFromEnv(), env = process.env, spawnImpl = spawnDetached, cwd = process.cwd()) {
   try {
     if (event !== "SessionEnd") return;
     if (!sessionId || env.OUTERLAYER_WORK === void 0) return;
-    const { parseWorkItemEnv } = await import('./work-launch-YI4CJDAP.js');
+    const { parseWorkItemEnv } = await import('./work-launch-R5HTAP6X.js');
     const parsed = parseWorkItemEnv(env.OUTERLAYER_WORK);
     if ("reason" in parsed) return;
     spawnImpl(
       process.execPath,
-      [process.argv[1], "work", "link-session", String(parsed.number), "--session-id", sessionId, "--ended"],
-      join(spoolDir(home), "hook-errors.log"),
+      [process.argv[1], "work", "link-session", String(parsed.number), "--session-id", sessionId, "--ended", LOG_FAILURES_FLAG],
       cwd
     );
   } catch {
@@ -638,7 +628,7 @@ async function runHookFast(event, home = homeFromEnv(), read = readStdin, env =
       recordHookErrorsSeen(home, hookErrorsBytes);
       if (contextPossiblyGoverned(sessionCwd, home)) {
         try {
-          const { materializeContext: materialize } = await import('./context-materialize-G2FUFC72.js');
+          const { materializeContext: materialize } = await import('./context-materialize-QL33HDJN.js');
           const sessionId = typeof payload.session_id === "string" ? payload.session_id : "unknown";
           const result = await materialize({ cwd: sessionCwd, sessionId, home });
           materializeMessage = result.message;
@@ -677,7 +667,9 @@ async function runHookFast(event, home = homeFromEnv(), read = readStdin, env =
     logHookError(home, err);
   }
 }
+var hookErrorsLogged = 0;
 function logHookError(home, err) {
+  hookErrorsLogged++;
   try {
     const dir = spoolDir(home);
     mkdirSync(dir, { recursive: true });
@@ -690,5 +682,15 @@ function logHookError(home, err) {
   } catch {
   }
 }
+function recordLinkExitFailure(argv, home = homeFromEnv(), target = process) {
+  const at = argv.indexOf("link-session");
+  if (at < 0 || !argv.includes(LOG_FAILURES_FLAG)) return;
+  const number = argv[at + 1] ?? "?";
+  target.once("exit", (code) => {
+    if (code !== 0 && hookErrorsLogged === 0) {
+      logHookError(home, new Error(`work link-session #${number} exited with code ${code} before it reported a failure`));
+    }
+  });
+}
 
-export { AUTO_SYNC_DEBOUNCE_MS, SYNC_STALE_AFTER_MS, WORK_LEASE_RENEW_DEBOUNCE_MS, WORK_LINK_RETRIES, assessSyncHealth, checkInstalledCliStaleness, contextPossiblyGoverned, formatAgo, handleWorkLaunch, handleWorkSessionEnd, hookFiredMarkerPath, installedCliDistDir, maybeAutoSync, maybeRenewWorkLease, readSyncStatus, refreshCommand, runHookFast, sanitizeForContext, spoolDir, workspaceRootOf, writeSyncStatus };
+export { AUTO_SYNC_DEBOUNCE_MS, SYNC_STALE_AFTER_MS, WORK_LEASE_RENEW_DEBOUNCE_MS, WORK_LINK_RETRIES, assessSyncHealth, checkInstalledCliStaleness, contextPossiblyGoverned, formatAgo, handleWorkLaunch, handleWorkSessionEnd, hookFiredMarkerPath, installedCliDistDir, logHookError, maybeAutoSync, maybeRenewWorkLease, readSyncStatus, recordLinkExitFailure, refreshCommand, runHookFast, sanitizeForContext, spoolDir, workspaceRootOf, writeSyncStatus };

package/dist/{chunk-ZMYPLFG3.js → chunk-M3SQ4YGD.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
 import { C } from './chunk-YRYMNBGQ.js';
-import { resolvePackRoot, loadTemplateFiles, loadMaintainedFiles, TEMPLATE_SKILLS, skillDir, writeMaintainedFiles, MAINTAINED_SKILLS } from './chunk-WO2BXCTQ.js';
+import { resolvePackRoot, loadTemplateFiles, loadMaintainedFiles, TEMPLATE_SKILLS, skillDir, writeMaintainedFiles, MAINTAINED_SKILLS } from './chunk-VXLJORHL.js';
 import { resolvePackageVersion } from './chunk-RA3O54FC.js';
 import { existsSync, mkdirSync, writeFileSync } from 'fs';
 import { join, dirname } from 'path';

package/dist/{chunk-H4CK2YK4.js → chunk-MQPRB5K7.js}

@@ -1,17 +1,17 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-import { isLinkedRepository } from './chunk-D2KWEAN6.js';
 import { readStatuslineState, STATE_FRESH_MS } from './chunk-F47JBIAW.js';
-import { resolveCredentials, getJson, WorkCommandError } from './chunk-RMAZ2NWA.js';
-import { sanitizeTerminal } from './chunk-WOBNRVQT.js';
-import { resolveRepoIdentity, compareVersions, SUPPORTED_VERSIONS } from './chunk-EX6M5JPR.js';
+import { resolveCredentials, getJson, WorkCommandError } from './chunk-DGAIVMMN.js';
+import { isLinkedRepository } from './chunk-SSU747O6.js';
+import { sanitizeTerminal } from './chunk-ZYHKJKSU.js';
+import { resolveRepoIdentity, compareVersions, SUPPORTED_VERSIONS } from './chunk-D6FXM5OW.js';
 import { C } from './chunk-YRYMNBGQ.js';
 import { readSettings, settingsPath, isOurStatuslineSlot, statuslineWrappedOriginal, REGISTERED_EVENTS, isOurHookCommand, ourCommandBins, cliBinResolvable, ourDirectScriptBins, wrappedOriginalCommand } from './chunk-5QRP3MVS.js';
-import { readPin, readContextManifest, readDegraded, readSourceCache } from './chunk-WIOZAJ2W.js';
+import { readPin, readContextManifest, readDegraded, readSourceCache } from './chunk-ZZXLM64C.js';
 import { defaultFetch } from './chunk-BCLJSQCV.js';
 import { resolveGatewayCredentials } from './chunk-BOLTI6LR.js';
 import { readCloudConfig } from './chunk-EABW6AJQ.js';
-import { sanitizeForContext, spoolDir, assessSyncHealth, readSyncStatus, SYNC_STALE_AFTER_MS, formatAgo, checkInstalledCliStaleness, workspaceRootOf, hookFiredMarkerPath, refreshCommand } from './chunk-UFFXNXLQ.js';
+import { sanitizeForContext, spoolDir, assessSyncHealth, readSyncStatus, SYNC_STALE_AFTER_MS, formatAgo, checkInstalledCliStaleness, workspaceRootOf, hookFiredMarkerPath, refreshCommand } from './chunk-JPR2WHHF.js';
 import { deadHooksState, preparePackageManagerCommand, contextExcludesPresent } from './chunk-XCCLFVXM.js';
 import { findGitDirs } from './chunk-BJ3KTMDH.js';
 import { homeFromEnv } from './chunk-VNVZDWO3.js';
@@ -1004,7 +1004,7 @@ function doctorExitCode(checks) {
 
 // src/doctor-report.ts
 async function gatherDoctorChecks() {
-  const { defaultRunnerConfigPath, hasRunnerBlock, loadRunnerConfig, runnerVmOf } = await import('./config-HL2AIR3K.js');
+  const { defaultRunnerConfigPath, hasRunnerBlock, loadRunnerConfig, runnerVmOf } = await import('./config-I3TVFYLH.js');
   const configPath = defaultRunnerConfigPath();
   const checks = runDoctor({ runnerHost: hasRunnerBlock(configPath) });
   const credential = await credentialChecks();
@@ -1012,11 +1012,11 @@ async function gatherDoctorChecks() {
   if (credential[0]?.status === "pass") checks.push(...await githubAppChecks());
   const runnerVm = runnerVmOf(configPath);
   if (runnerVm !== void 0) {
-    const { realLima } = await import('./lima-XN65D7GN.js');
+    const { realLima } = await import('./lima-7NPCNGWT.js');
     const { runnerVmCheck } = await import('./doctor-53F2PYY7.js');
     checks.push(runnerVmCheck(configPath, { lima: realLima(), home: homeFromEnv(), instance: runnerVm.instance }));
   } else if (hasRunnerBlock(configPath)) {
-    const { runnerHostChecks } = await import('./doctor-MOA3RIEP.js');
+    const { runnerHostChecks } = await import('./doctor-FVDT3KJZ.js');
     const hooks = (() => {
       try {
         return loadRunnerConfig(configPath).hooks;
@@ -1047,7 +1047,15 @@ async function gatherDoctorChecks() {
         return void 0;
       }
     })();
-    checks.push(...await runnerHostChecks({ configPath, hooks, gateway, repos, runner }));
+    const service = await (async () => {
+      const { existsSync: existsSync2 } = await import('fs');
+      if (process.platform !== "linux" || !existsSync2("/run/systemd/system")) return void 0;
+      const { inspectService, realInspectProbes } = await import('./inspect-XAUSB7L3.js');
+      const { DEFAULT_UNIT_NAME } = await import('./install-NMAPLLBQ.js');
+      const { dirname: dirname2 } = await import('path');
+      return inspectService(DEFAULT_UNIT_NAME, dirname2(configPath), realInspectProbes());
+    })();
+    checks.push(...await runnerHostChecks({ configPath, hooks, gateway, repos, runner, service }));
   }
   return checks;
 }

package/dist/{chunk-AUFG23AA.js → chunk-OD2VTIHN.js}

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
+import { authorEnvironment, withHooksPath } from './chunk-HKMPVPO7.js';
 import { existsSync, unlinkSync, chmodSync } from 'fs';
 import { request as request$1, createServer } from 'http';
 import { request } from 'https';
@@ -344,52 +345,6 @@ async function startBuildServices(input) {
   }
 }
 
-// src/runner/commit-identity.ts
-var NOREPLY_SUFFIX = "@users.noreply.github.com";
-var MAX_LENGTH = 200;
-function parseIdentity(value) {
-  if (typeof value !== "object" || value === null) return void 0;
-  const { name, email } = value;
-  if (typeof name !== "string" || typeof email !== "string") return void 0;
-  if (name.trim() === "" || name.length > MAX_LENGTH || /[\r\n\0<>]/.test(name)) return void 0;
-  if (email.length > MAX_LENGTH || !email.endsWith(NOREPLY_SUFFIX) || /[\s\0<>]/.test(email) || email.length === NOREPLY_SUFFIX.length) return void 0;
-  return { name, email };
-}
-function parseClaimIdentity(data) {
-  const author = parseIdentity(data.commitAuthor);
-  if (author === void 0) return void 0;
-  const coAuthor = parseIdentity(data.coAuthor);
-  return coAuthor === void 0 ? { author } : { author, coAuthor };
-}
-function authorEnvironment(identity) {
-  if (identity === void 0) return {};
-  return {
-    GIT_AUTHOR_NAME: identity.name,
-    GIT_AUTHOR_EMAIL: identity.email,
-    GIT_COMMITTER_NAME: identity.name,
-    GIT_COMMITTER_EMAIL: identity.email
-  };
-}
-function configCount(env) {
-  const raw = String(env.GIT_CONFIG_COUNT);
-  return /^[0-9]+$/.test(raw) ? Number(raw) : 0;
-}
-function withHooksPath(env, dir) {
-  const at = configCount(env);
-  return {
-    ...env,
-    GIT_CONFIG_COUNT: String(at + 1),
-    [`GIT_CONFIG_KEY_${at}`]: "core.hooksPath",
-    [`GIT_CONFIG_VALUE_${at}`]: dir
-  };
-}
-function commitIdentityRecord(identity) {
-  return {
-    author: identity === void 0 ? "host" : "app",
-    coAuthor: identity?.coAuthor !== void 0 && identity.hooksPath !== void 0 ? "credited" : "none"
-  };
-}
-
 // src/runner/container/environment.ts
 var RELAY_PORT = 3128;
 var JOB_MOUNT = "/outerlayer/job";
@@ -498,6 +453,23 @@ function buildEnvironment(input) {
     skippedTokenVariables
   };
 }
+function checkEnvironment(input) {
+  const env = buildEnvironment({
+    config: input.config,
+    item: input.item,
+    itemKey: void 0,
+    repository: input.repository,
+    hostEnv: input.hostEnv,
+    containerEnv: input.containerEnv,
+    builtIns: false
+  });
+  const withheld = /* @__PURE__ */ new Set(["OUTERLAYER_URL", "OUTERLAYER_API_KEY", ...CLAUDE_CREDENTIAL_VARIABLES]);
+  const literals = {};
+  for (const [name, value] of Object.entries(env.literals)) if (!withheld.has(name)) literals[name] = value;
+  const passed = {};
+  for (const [name, value] of Object.entries(env.passed)) if (!withheld.has(name)) passed[name] = value;
+  return { literals, passed };
+}
 function parseIsolation(value) {
   return value === "container" || value === "vm" ? value : "shared-user";
 }
@@ -531,4 +503,4 @@ function withTunnelRecord(environment, record, onlyWhenUsed = false) {
   };
 }
 
-export { AGENT_CREDENTIAL_MISSING, BUILT_IN_NAMES, CHECKOUT_DIR, CLAUDE_CREDENTIAL_VARIABLES, CLAUDE_PORT, CLAUDE_SOCKET, DESTINATION_BASE_PORT, GATEWAY_PORT, GATEWAY_SOCKET, JOB_MOUNT, RELAY_PORT, authorEnvironment, buildEnvironment, builtInEnvironment, claudeCredential, commitIdentityRecord, containerLocalAddress, destinationEnvironment, headerVariables, isRefusedInConfig, isReservedVariable, parseClaimIdentity, parseIsolation, proxyEnvironment, resolveDestinations, sharedUserEnvironment, startBuildServices, withHooksPath, withTunnelRecord };
+export { AGENT_CREDENTIAL_MISSING, BUILT_IN_NAMES, CHECKOUT_DIR, CLAUDE_CREDENTIAL_VARIABLES, CLAUDE_PORT, CLAUDE_SOCKET, DESTINATION_BASE_PORT, GATEWAY_PORT, GATEWAY_SOCKET, JOB_MOUNT, RELAY_PORT, buildEnvironment, builtInEnvironment, checkEnvironment, claudeCredential, containerLocalAddress, destinationEnvironment, headerVariables, isRefusedInConfig, isReservedVariable, parseIsolation, proxyEnvironment, resolveDestinations, sharedUserEnvironment, startBuildServices, withTunnelRecord };

package/dist/chunk-OUUINEYB.js

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+import { parseSize } from './chunk-F6GFZXZ3.js';
+
+createRequire(import.meta.url);
+
+// src/runner/service/fit.ts
+var GIB = 1024 ** 3;
+var RUNNER_RESERVE_BYTES = 2 * GIB;
+function gib(bytes) {
+  return `${Number((bytes / GIB).toFixed(1))} GiB`;
+}
+function checkFit(input) {
+  const perBuild = parseSize(input.buildMemory);
+  if (perBuild === void 0) return { fits: true };
+  const neededBytes = input.concurrency * perBuild;
+  const availableBytes = Math.max(0, input.usableBytes - RUNNER_RESERVE_BYTES);
+  if (neededBytes <= availableBytes) return { fits: true };
+  return {
+    fits: false,
+    neededBytes,
+    availableBytes,
+    message: `runner.concurrency ${input.concurrency} times runner.build.memory ${input.buildMemory} needs ${gib(neededBytes)}, and ${gib(availableBytes)} is available (${gib(input.usableBytes)} of memory less ${gib(RUNNER_RESERVE_BYTES)} for the runner and the system)`
+  };
+}
+
+export { RUNNER_RESERVE_BYTES, checkFit };

package/dist/chunk-PUN7LMNS.js

@@ -0,0 +1,39 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+import { fetchFactories, selectFactory, saveFactoryConnection, connectedLine } from './chunk-SSU747O6.js';
+import { resolveRepoIdentity } from './chunk-D6FXM5OW.js';
+import { resolveGatewayCredentials } from './chunk-BOLTI6LR.js';
+import { findGitDirs, readRepoConnection } from './chunk-BJ3KTMDH.js';
+import { homeFromEnv } from './chunk-VNVZDWO3.js';
+
+createRequire(import.meta.url);
+
+// src/auto-connect.ts
+async function autoConnect(opts) {
+  const env = opts.env ?? process.env;
+  const home = opts.home ?? homeFromEnv(env);
+  const cwd = opts.cwd ?? process.cwd();
+  const resolved = resolveGatewayCredentials({ url: opts.url, apiKey: opts.apiKey, appId: opts.appId, home, env, cwd });
+  if (resolved.ok || resolved.kind !== "login" || !resolved.credential || !resolved.url) return void 0;
+  const dirs = findGitDirs(cwd);
+  const repository = resolveRepoIdentity(cwd).gitRepo;
+  if (dirs === void 0 || repository === void 0) return void 0;
+  const listed = await fetchFactories(opts.fetchImpl ?? fetch, resolved.url, resolved.credential, repository);
+  if (!listed.ok || listed.factories.length === 0) return void 0;
+  const chosen = selectFactory(listed.factories, readRepoConnection(cwd), repository);
+  if (chosen.factory === void 0) {
+    return `you are logged in, but no factory is chosen for this repository, and more than one fits. Run \`outerlayer connect --factory <org>/<factory>\` with one of:
+${chosen.text}
+Or pass --app-id / set OUTERLAYER_APP_ID.`;
+  }
+  try {
+    saveFactoryConnection(dirs.gitCommonDir, void 0, chosen.factory, /* @__PURE__ */ new Date());
+  } catch {
+    return void 0;
+  }
+  process.stderr.write(`${connectedLine(repository, chosen.factory, chosen.reason)}
+`);
+  return void 0;
+}
+
+export { autoConnect };

package/dist/{install-cmd-7WXOIFDO.js → chunk-Q5G2ODUZ.js}

@@ -1,8 +1,7 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-import { isInLayout, packageRootIn, versionDir, switchCurrent, execStartLine } from './chunk-YYYXRJUW.js';
+import { isInLayout, packageRootIn, versionDir, switchCurrent, execStartLine } from './chunk-TI7B7UEO.js';
 import { RUNNER_DIR_MODE } from './chunk-ZM2IMMYN.js';
-import './chunk-Z5GEFMRW.js';
 import { realpathSync, readFileSync, mkdirSync, rmSync, cpSync, existsSync } from 'fs';
 import { dirname, sep, join } from 'path';
 

package/dist/{chunk-B2G7JHHB.js → chunk-R7STSBLC.js}

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-import { RELAY_PORT, GATEWAY_SOCKET, GATEWAY_PORT, CLAUDE_SOCKET, CLAUDE_PORT, DESTINATION_BASE_PORT } from './chunk-AUFG23AA.js';
+import { RELAY_PORT, GATEWAY_SOCKET, GATEWAY_PORT, CLAUDE_SOCKET, CLAUDE_PORT, DESTINATION_BASE_PORT } from './chunk-OD2VTIHN.js';
 import { symlinkSync, unlinkSync } from 'fs';
 import { join } from 'path';
 

package/dist/{chunk-OR6AEEDO.js → chunk-SSU747O6.js}

@@ -1,13 +1,62 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-import { dashboardBase, isRepositoryLinked, workPageUrl, notLinkedText } from './chunk-D2KWEAN6.js';
-import { sanitizeTerminal } from './chunk-WOBNRVQT.js';
-import { remoteLookupFailed } from './chunk-EX6M5JPR.js';
+import { sanitizeTerminal } from './chunk-ZYHKJKSU.js';
+import { remoteLookupFailed } from './chunk-D6FXM5OW.js';
+import { DEFAULT_DASHBOARD } from './chunk-USO2DKBD.js';
 import { resolveGatewayCredentials } from './chunk-BOLTI6LR.js';
-import { findGitDirs, readRepoConnection, writeRepoConnection } from './chunk-BJ3KTMDH.js';
+import { readCloudConfig } from './chunk-EABW6AJQ.js';
+import { writeRepoConnection, findGitDirs, readRepoConnection } from './chunk-BJ3KTMDH.js';
 import { createInterface } from 'readline/promises';
 
 createRequire(import.meta.url);
+
+// src/repository-link.ts
+var LINKS_TIMEOUT_MS = 15e3;
+var GITHUB_PREFIX = "github.com/";
+function isLinkedRepository(local, linked) {
+  if (linked.provider !== "github" || typeof linked.repository !== "string") return false;
+  return local.toLowerCase() === `${GITHUB_PREFIX}${linked.repository.toLowerCase()}`;
+}
+function ownerAndName(repository) {
+  return repository.toLowerCase().startsWith(GITHUB_PREFIX) ? repository.slice(GITHUB_PREFIX.length) : repository;
+}
+async function isRepositoryLinked(fetchImpl, gatewayUrl, token, appId, repository) {
+  if (!repository.toLowerCase().startsWith(GITHUB_PREFIX)) return null;
+  let res;
+  try {
+    res = await fetchImpl(`${gatewayUrl.replace(/\/+$/, "")}/v1/apps/${encodeURIComponent(appId)}/git/links`, {
+      method: "GET",
+      headers: { authorization: `Bearer ${token}`, "x-outerlayer-app-id": appId },
+      signal: AbortSignal.timeout(LINKS_TIMEOUT_MS)
+    });
+  } catch {
+    return null;
+  }
+  if (!res.ok) return null;
+  const listed = (await res.json().catch(() => void 0))?.data;
+  if (!Array.isArray(listed)) return null;
+  return listed.some((entry) => isLinkedRepository(repository, entry ?? {}));
+}
+function dashboardBase(home) {
+  const saved = readCloudConfig(home).dashboard;
+  const base = typeof saved === "string" && saved.trim() !== "" ? saved : DEFAULT_DASHBOARD;
+  return base.replace(/\/+$/, "");
+}
+function workPageUrl(home, organization, factory) {
+  return `${dashboardBase(home)}/orgs/${encodeURIComponent(organization)}/factories/${encodeURIComponent(factory)}/work`;
+}
+function notLinkedText(factoryName, repository, url) {
+  const shown = sanitizeTerminal(repository);
+  const name = sanitizeTerminal(ownerAndName(repository));
+  return `${factoryName} has no link to ${shown} yet, so work from this repository cannot reach it.
+Link it on the factory's Work page: ${url}
+  1. Connect GitHub repository, and grant the App access to ${name}.
+  2. Link repository, and pick ${name} and its default branch.
+Then run \`outerlayer connect\` again.
+`;
+}
+
+// src/connect-cmd.ts
 var REQUEST_TIMEOUT_MS = 15e3;
 var EXIT_NOT_LINKED = 2;
 var REASON_TEXT = {
@@ -72,10 +121,10 @@ function parseFactories(body) {
 function listText(factories, repository) {
   return factories.map((f) => `  ${slug(f)}  ${f.displayName}${f.linked === true ? ` (linked to ${repository})` : ""}`).join("\n");
 }
-async function fetchFactories(deps, url, token, repository) {
+async function fetchFactories(fetchImpl, url, token, repository) {
   let res;
   try {
-    res = await deps.fetchImpl(`${url.replace(/\/+$/, "")}/v1/me/factories?${new URLSearchParams({ repository }).toString()}`, {
+    res = await fetchImpl(`${url.replace(/\/+$/, "")}/v1/me/factories?${new URLSearchParams({ repository }).toString()}`, {
       method: "GET",
       headers: { authorization: `Bearer ${token}` },
       signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS)
@@ -99,6 +148,26 @@ async function fetchFactories(deps, url, token, repository) {
   }
   return { ok: true, factories };
 }
+function selectFactory(factories, saved, repository) {
+  const remembered = saved && factories.find((f) => f.id === saved.appId);
+  if (remembered) return { factory: remembered, reason: "saved" };
+  const linked = factories.filter((f) => f.linked === true);
+  if (linked.length === 1) return { factory: linked[0], reason: "linked" };
+  if (factories.length === 1) return { factory: factories[0], reason: "only" };
+  return { factory: void 0, values: factories.map(slug), text: listText(factories, repository) };
+}
+function saveFactoryConnection(gitCommonDir, saved, factory, now) {
+  if (saved?.appId === factory.id) return;
+  writeRepoConnection(gitCommonDir, {
+    appId: factory.id,
+    organization: { name: factory.organization.name, displayName: factory.organization.displayName },
+    factory: { name: factory.name, displayName: factory.displayName },
+    savedAt: now.toISOString()
+  });
+}
+function connectedLine(repository, factory, reason) {
+  return `Connected ${repository} to factory "${factory.displayName}" in ${factory.organization.displayName} (${REASON_TEXT[reason]}).`;
+}
 async function choose(flags, deps, factories, saved, repository) {
   if (flags.factory !== void 0) {
     const wanted = flags.factory.toLowerCase();
@@ -108,11 +177,9 @@ async function choose(flags, deps, factories, saved, repository) {
 ${listText(factories, repository)}`;
     return result(1, "failed", `--factory ${flags.factory} names no factory you can use`, message);
   }
-  const remembered = saved && factories.find((f) => f.id === saved.appId);
-  if (remembered) return { factory: remembered, reason: "saved" };
+  const decided = selectFactory(factories, saved, repository);
+  if (decided.factory) return { factory: decided.factory, reason: decided.reason };
   const linked = factories.filter((f) => f.linked === true);
-  if (linked.length === 1) return { factory: linked[0], reason: "linked" };
-  if (factories.length === 1) return { factory: factories[0], reason: "only" };
   if (!deps.isTerminal) {
     const why = linked.length > 1 ? `${repository} is linked to more than one factory you can use` : `you can use more than one factory, and none is the only one ${repository} is linked to`;
     const message = `${why}, and there is no terminal to ask on.
@@ -169,7 +236,7 @@ async function runConnect(flags, deps) {
     const message = "no gateway address is saved. Run `outerlayer login` to sign in.";
     return result(1, "failed", message, message);
   }
-  const listed = await fetchFactories(deps, creds.url, creds.credential, repository);
+  const listed = await fetchFactories(deps.fetchImpl, creds.url, creds.credential, repository);
   if (!listed.ok) return listed.result;
   const { factories } = listed;
   if (factories.length === 0) {
@@ -181,20 +248,13 @@ async function runConnect(flags, deps) {
   const choice = await choose(flags, deps, factories, saved, repository);
   if ("code" in choice) return choice;
   const { factory, reason } = choice;
-  if (saved?.appId !== factory.id) {
-    try {
-      writeRepoConnection(dirs.gitCommonDir, {
-        appId: factory.id,
-        organization: { name: factory.organization.name, displayName: factory.organization.displayName },
-        factory: { name: factory.name, displayName: factory.displayName },
-        savedAt: deps.now().toISOString()
-      });
-    } catch (err) {
-      const message = `could not save the connection under ${dirs.gitCommonDir}: ${err instanceof Error ? err.message : String(err)}`;
-      return result(1, "failed", "could not save the connection", message);
-    }
+  try {
+    saveFactoryConnection(dirs.gitCommonDir, saved, factory, deps.now());
+  } catch (err) {
+    const message = `could not save the connection under ${dirs.gitCommonDir}: ${err instanceof Error ? err.message : String(err)}`;
+    return result(1, "failed", "could not save the connection", message);
   }
-  const connected = `Connected ${repository} to factory "${factory.displayName}" in ${factory.organization.displayName} (${REASON_TEXT[reason]}).
+  const connected = `${connectedLine(repository, factory, reason)}
 `;
   const why = `connected to ${slug(factory)}: ${REASON_TEXT[reason]}`;
   const linked = await isRepositoryLinked(deps.fetchImpl, creds.url, creds.credential, factory.id, repository);
@@ -229,4 +289,4 @@ async function runConnectCommand(flags, deps, out) {
   return r.code;
 }
 
-export { promptOnTerminal, realConnectDeps, runConnect, runConnectCommand };
+export { connectedLine, fetchFactories, isLinkedRepository, promptOnTerminal, realConnectDeps, runConnect, runConnectCommand, saveFactoryConnection, selectFactory };

package/dist/chunk-T6OIJQRT.js

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+import { RUNNER_DIR_MODE, RUNNER_FILE_MODE } from './chunk-ZM2IMMYN.js';
+import { existsSync, readFileSync, mkdirSync, writeFileSync } from 'fs';
+import { dirname } from 'path';
+
+createRequire(import.meta.url);
+function readJobFile(path) {
+  if (!existsSync(path)) return null;
+  try {
+    return JSON.parse(readFileSync(path, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function readJobFileChecked(path) {
+  if (!existsSync(path)) return { kind: "missing" };
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf8"));
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return { kind: "unreadable" };
+    return { kind: "ok", job: parsed };
+  } catch {
+    return { kind: "unreadable" };
+  }
+}
+function writeJobFile(path, job) {
+  mkdirSync(dirname(path), { recursive: true, mode: RUNNER_DIR_MODE });
+  writeFileSync(path, JSON.stringify(job, null, 2), { mode: RUNNER_FILE_MODE });
+}
+
+export { readJobFile, readJobFileChecked, writeJobFile };