deepline 0.3.461 → 0.3.462

package/dist/cli/{chunk-RY4IVOU3.mjs → chunk-6RNQGWFD.mjs}

@@ -1,6 +1,5 @@
 import {
   AuthError,
-  ConfigError,
   RateLimitError,
   ToolRateLimitError
 } from "./chunk-4QF2K7TM.mjs";
@@ -17,636 +16,7 @@ import {
 } from "./chunk-HBL4PM5Q.mjs";
 import {
   SDK_RELEASE
-} from "./chunk-T3MVIPHG.mjs";
-
-// src/config.ts
-import {
-  existsSync,
-  mkdirSync,
-  readdirSync,
-  realpathSync,
-  readFileSync,
-  statSync,
-  writeFileSync
-} from "fs";
-import { homedir } from "os";
-import { dirname, isAbsolute, join, resolve } from "path";
-var HOST_URL_ENV = "DEEPLINE_HOST_URL";
-var API_KEY_ENV = "DEEPLINE_API_KEY";
-var ACTIVE_ORG_ID_ENV = "DEEPLINE_ACTIVE_ORG_ID";
-var ACTIVE_ORG_NAME_ENV = "DEEPLINE_ACTIVE_ORG_NAME";
-var FEATURES_ENV = "DEEPLINE_FEATURES";
-var PROD_URL = "https://code.deepline.com";
-var DEFAULT_TIMEOUT = 6e4;
-var DEFAULT_MAX_RETRIES = 3;
-var PROJECT_DEEPLINE_ENV_FILE = ".env.deepline";
-var COWORK_IGNORED_WORKSPACE_DIRS = /* @__PURE__ */ new Set([
-  ".auto-memory",
-  ".claude",
-  ".remote-plugins",
-  "outputs",
-  "plugins",
-  "uploads"
-]);
-var COWORK_PROJECT_MARKERS = [
-  ".deepline",
-  ".env.deepline",
-  ".git",
-  "AGENTS.md",
-  "package.json",
-  "pyproject.toml"
-];
-var CLI_ENV_ALLOWED_KEYS = /* @__PURE__ */ new Set([
-  HOST_URL_ENV,
-  API_KEY_ENV,
-  ACTIVE_ORG_ID_ENV,
-  ACTIVE_ORG_NAME_ENV,
-  FEATURES_ENV
-]);
-function featureEnvValues(data) {
-  if (!Array.isArray(data.features)) return {};
-  return {
-    [FEATURES_ENV]: data.features.filter(
-      (key) => typeof key === "string" && key.trim() !== ""
-    ).map((key) => key.trim()).join(",")
-  };
-}
-function storedHostApiKey(baseUrl) {
-  return loadCliEnv(normalizeBaseUrl(baseUrl) || baseUrl)[API_KEY_ENV] ?? "";
-}
-function storedHostFeatures(baseUrl) {
-  return loadCliEnv(normalizeBaseUrl(baseUrl) || baseUrl)[FEATURES_ENV];
-}
-function baseUrlSlug(baseUrl) {
-  let url;
-  try {
-    url = new URL(baseUrl);
-  } catch {
-    return "unknown";
-  }
-  const host = url.hostname || "unknown";
-  const port = url.port ? Number.parseInt(url.port, 10) : null;
-  let slug = host.replace(/[^a-zA-Z0-9]/g, "-");
-  if (port && port !== 80 && port !== 443) {
-    slug = `${slug}-${port}`;
-  }
-  return slug.toLowerCase().replace(/^-+|-+$/g, "");
-}
-function parseEnvFile(filePath) {
-  if (!existsSync(filePath)) return {};
-  const env = {};
-  const content = readFileSync(filePath, "utf-8");
-  for (const line of content.split(/\r?\n/)) {
-    const trimmed = line.trim();
-    if (!trimmed || trimmed.startsWith("#")) continue;
-    const eqIndex = trimmed.indexOf("=");
-    if (eqIndex < 0) continue;
-    const key = trimmed.slice(0, eqIndex).trim();
-    let value = trimmed.slice(eqIndex + 1).trim();
-    if (value.length >= 2 && value.startsWith('"') && value.endsWith('"')) {
-      try {
-        value = JSON.parse(value);
-      } catch {
-        value = value.slice(1, -1);
-      }
-    } else if (value.length >= 2 && value.startsWith("'") && value.endsWith("'")) {
-      value = value.slice(1, -1);
-    }
-    if (key && value) {
-      env[key] = value;
-    }
-  }
-  return env;
-}
-function findNearestEnvFile(name, startDir = process.cwd()) {
-  let current = resolve(startDir);
-  while (true) {
-    const filePath = join(current, name);
-    if (existsSync(filePath)) return filePath;
-    const parent = dirname(current);
-    if (parent === current) return null;
-    current = parent;
-  }
-}
-function isDirectory(path) {
-  try {
-    return statSync(path).isDirectory();
-  } catch {
-    return false;
-  }
-}
-function canonicalPath(path) {
-  try {
-    return realpathSync(path);
-  } catch {
-    return resolve(path);
-  }
-}
-function isTruthy(value) {
-  return /^(1|true|yes|on)$/i.test(value?.trim() ?? "");
-}
-function sessionRootFromPath(path) {
-  const trimmed = path?.trim();
-  if (!trimmed) return null;
-  const match = /^\/sessions\/[^/]+(?=\/|$)/.exec(trimmed);
-  return match?.[0] ?? null;
-}
-function coworkSessionRoot() {
-  const home = process.env.HOME?.trim();
-  const homeSessionRoot = sessionRootFromPath(home);
-  if (homeSessionRoot && isDirectory(join(homeSessionRoot, "mnt"))) {
-    return homeSessionRoot;
-  }
-  const cwdSessionRoot = sessionRootFromPath(process.cwd());
-  if (cwdSessionRoot && isDirectory(join(cwdSessionRoot, "mnt"))) {
-    return cwdSessionRoot;
-  }
-  if (isTruthy(process.env.CLAUDE_CODE_REMOTE) && home) {
-    const mountedRoot = join(home, "mnt");
-    if (isDirectory(mountedRoot)) return resolve(home);
-  }
-  return null;
-}
-function isCoworkLikeSandbox() {
-  const home = process.env.HOME?.trim();
-  return isTruthy(process.env.CLAUDE_CODE_REMOTE) || sessionRootFromPath(home) !== null || sessionRootFromPath(process.cwd()) !== null;
-}
-function coworkProjectScore(path) {
-  let score = 0;
-  for (const marker of COWORK_PROJECT_MARKERS) {
-    if (existsSync(join(path, marker))) score += 1;
-  }
-  return score;
-}
-function listCoworkWorkspaceDirCandidates() {
-  if (!isCoworkLikeSandbox()) {
-    return [];
-  }
-  const explicitProjectDir = process.env.CLAUDE_PROJECT_DIR?.trim();
-  if (explicitProjectDir && isDirectory(explicitProjectDir)) {
-    return [resolve(explicitProjectDir)];
-  }
-  const sessionRoot = coworkSessionRoot();
-  if (!sessionRoot) return [];
-  const mountedRoot = join(sessionRoot, "mnt");
-  if (!isDirectory(mountedRoot)) return [];
-  let names;
-  try {
-    names = readdirSync(mountedRoot).sort();
-  } catch {
-    return [];
-  }
-  const candidates = [];
-  for (const name of names) {
-    if (name.startsWith(".") || COWORK_IGNORED_WORKSPACE_DIRS.has(name)) {
-      continue;
-    }
-    const candidate = join(mountedRoot, name);
-    if (isDirectory(candidate)) candidates.push(candidate);
-  }
-  if (candidates.length <= 1) return candidates;
-  const projectLike = candidates.filter(
-    (candidate) => coworkProjectScore(candidate) > 0
-  );
-  return projectLike.length > 0 ? projectLike : candidates;
-}
-function isInIgnoredCoworkMount(path) {
-  const sessionRoot = coworkSessionRoot();
-  if (!sessionRoot) return false;
-  const mountedRoot = canonicalPath(join(sessionRoot, "mnt"));
-  const resolvedPath = canonicalPath(path);
-  const prefix = `${mountedRoot}/`;
-  if (!resolvedPath.startsWith(prefix)) return false;
-  const relativePath = resolvedPath.slice(prefix.length);
-  const mountName = relativePath.split("/")[0];
-  return mountName.startsWith(".") || COWORK_IGNORED_WORKSPACE_DIRS.has(mountName);
-}
-function detectCoworkWorkspaceDir() {
-  const candidates = listCoworkWorkspaceDirCandidates();
-  return candidates.length === 1 ? candidates[0] : null;
-}
-function loadProjectEnvCandidates(startDir = process.cwd()) {
-  const filePaths = [];
-  const sources = /* @__PURE__ */ new Map();
-  const nearestFile = findNearestEnvFile(PROJECT_DEEPLINE_ENV_FILE, startDir);
-  if (nearestFile && !isInIgnoredCoworkMount(nearestFile)) {
-    filePaths.push(nearestFile);
-    sources.set(resolve(nearestFile), "nearest");
-  }
-  const coworkWorkspaceDir = detectCoworkWorkspaceDir();
-  if (coworkWorkspaceDir) {
-    const coworkFile = join(coworkWorkspaceDir, PROJECT_DEEPLINE_ENV_FILE);
-    if (existsSync(coworkFile) && !filePaths.some((filePath) => resolve(filePath) === resolve(coworkFile))) {
-      filePaths.push(coworkFile);
-      sources.set(resolve(coworkFile), "cowork");
-    }
-  }
-  return filePaths.map((filePath) => ({
-    filePath,
-    env: parseEnvFile(filePath),
-    source: sources.get(resolve(filePath)) ?? "nearest"
-  }));
-}
-function normalizeBaseUrl(baseUrl) {
-  const trimmed = baseUrl?.trim().replace(/\/+$/, "") ?? "";
-  if (!trimmed) return "";
-  try {
-    const parsed = new URL(trimmed);
-    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
-      return "";
-    }
-    return parsed.toString().replace(/\/+$/, "");
-  } catch {
-    return "";
-  }
-}
-function firstNonEmpty(...values) {
-  for (const value of values) {
-    const trimmed = value?.trim();
-    if (trimmed) return trimmed;
-  }
-  return "";
-}
-function formatEnvFileValue(value) {
-  return /^[a-zA-Z0-9_./:@%+=,-]+$/.test(value) ? value : JSON.stringify(value);
-}
-function mergePersistedEnvValues(existing, values) {
-  const merged = { ...existing, ...values };
-  const nextApiKey = values[API_KEY_ENV];
-  if (nextApiKey !== void 0 && nextApiKey !== existing[API_KEY_ENV] && values[ACTIVE_ORG_ID_ENV] === void 0) {
-    delete merged[ACTIVE_ORG_ID_ENV];
-    delete merged[ACTIVE_ORG_NAME_ENV];
-    delete merged[FEATURES_ENV];
-  }
-  if (values[FEATURES_ENV] === "") {
-    delete merged[FEATURES_ENV];
-  }
-  return merged;
-}
-function persistedEnvLines(values) {
-  return Object.entries(values).filter(
-    ([key, value]) => CLI_ENV_ALLOWED_KEYS.has(key) && value.trim() !== ""
-  ).map(([key, value]) => `${key}=${formatEnvFileValue(value)}`);
-}
-function sdkCliConfigDir(baseUrl) {
-  const home = process.env.HOME?.trim() || homedir();
-  return join(home, ".local", "deepline", baseUrlSlug(baseUrl || PROD_URL));
-}
-function sdkCliStateDirPath(baseUrl, homeDir = process.env.HOME?.trim() || homedir()) {
-  return join(
-    homeDir,
-    ".local",
-    "deepline",
-    baseUrlSlug(baseUrl || PROD_URL),
-    "sdk-cli"
-  );
-}
-function sdkCliEnvFilePath(baseUrl) {
-  return join(sdkCliConfigDir(baseUrl), ".env");
-}
-function loadCliEnv(baseUrl = PROD_URL) {
-  return parseEnvFile(sdkCliEnvFilePath(baseUrl));
-}
-function hostConfigDirPath(baseUrl) {
-  return sdkCliConfigDir(baseUrl);
-}
-function hostEnvFilePath(baseUrl) {
-  return sdkCliEnvFilePath(baseUrl);
-}
-function saveHostEnvValues(baseUrl, values) {
-  const filePath = sdkCliEnvFilePath(baseUrl);
-  const dir = dirname(filePath);
-  if (!existsSync(dir)) {
-    mkdirSync(dir, { recursive: true });
-  }
-  const existing = parseEnvFile(filePath);
-  const merged = mergePersistedEnvValues(existing, values);
-  const lines = persistedEnvLines(merged);
-  writeFileSync(filePath, `${lines.join("\n")}
-`, "utf-8");
-}
-function loadGlobalCliEnv() {
-  return loadCliEnv(PROD_URL);
-}
-function autoDetectBaseUrl() {
-  const projectEnvs = loadProjectEnvCandidates();
-  const globalEnv = loadGlobalCliEnv();
-  return normalizeBaseUrl(process.env[HOST_URL_ENV] ?? "") || firstNonEmpty(
-    ...projectEnvs.map(({ env }) => normalizeBaseUrl(env[HOST_URL_ENV]))
-  ) || normalizeBaseUrl(globalEnv[HOST_URL_ENV] ?? "") || PROD_URL;
-}
-function resolveApiKeyForBaseUrl(baseUrl, explicitApiKey) {
-  const normalizedBaseUrl = normalizeBaseUrl(baseUrl);
-  const projectEnvs = loadProjectEnvCandidates();
-  const cliEnv = loadCliEnv(normalizedBaseUrl || baseUrl);
-  return firstNonEmpty(
-    explicitApiKey,
-    process.env[API_KEY_ENV],
-    ...projectEnvs.map(({ env }) => {
-      const projectBaseUrl = normalizeBaseUrl(env[HOST_URL_ENV] ?? "");
-      return projectBaseUrl === normalizedBaseUrl ? env[API_KEY_ENV] : "";
-    }),
-    cliEnv[API_KEY_ENV]
-  );
-}
-function resolveProjectApiKeyForBaseUrl(baseUrl, startDir = process.cwd()) {
-  const normalizedBaseUrl = normalizeBaseUrl(baseUrl);
-  return firstNonEmpty(
-    ...loadProjectEnvCandidates(startDir).map(({ env }) => {
-      const projectBaseUrl = normalizeBaseUrl(env[HOST_URL_ENV] ?? "");
-      return projectBaseUrl === normalizedBaseUrl ? env[API_KEY_ENV] : "";
-    })
-  );
-}
-function resolveGlobalApiKeyForBaseUrl(baseUrl) {
-  return firstNonEmpty(
-    process.env[API_KEY_ENV],
-    loadCliEnv(normalizeBaseUrl(baseUrl) || baseUrl)[API_KEY_ENV]
-  );
-}
-function getResolvedProjectAuthSource(baseUrl, apiKey, startDir = process.cwd()) {
-  const normalizedBaseUrl = normalizeBaseUrl(baseUrl);
-  const normalizedApiKey = apiKey.trim();
-  if (!normalizedBaseUrl || !normalizedApiKey) return null;
-  return loadProjectEnvCandidates(startDir).find(({ env }) => {
-    const projectBaseUrl = normalizeBaseUrl(env[HOST_URL_ENV] ?? "");
-    return projectBaseUrl === normalizedBaseUrl && (env[API_KEY_ENV] ?? "").trim() === normalizedApiKey;
-  }) ?? null;
-}
-function resolveBaseUrlOnly(options) {
-  const baseUrl = normalizeBaseUrl(
-    options?.baseUrl?.trim() || autoDetectBaseUrl()
-  );
-  if (!baseUrl) {
-    throw new ConfigError(
-      `Invalid ${HOST_URL_ENV}. Expected an http(s) URL such as https://code.deepline.com.`
-    );
-  }
-  return baseUrl;
-}
-function resolveConfig(options) {
-  const baseUrl = normalizeBaseUrl(
-    options?.baseUrl?.trim() || autoDetectBaseUrl()
-  );
-  if (!baseUrl) {
-    throw new ConfigError(
-      `Invalid ${HOST_URL_ENV}. Expected an http(s) URL such as https://code.deepline.com.`
-    );
-  }
-  const apiKey = resolveApiKeyForBaseUrl(baseUrl, options?.apiKey);
-  if (!apiKey) {
-    throw new ConfigError(
-      `No API key found. Set ${API_KEY_ENV}, add it to .env.deepline, or run: deepline auth register`
-    );
-  }
-  return {
-    apiKey,
-    baseUrl,
-    timeout: options?.timeout ?? DEFAULT_TIMEOUT,
-    maxRetries: options?.maxRetries ?? DEFAULT_MAX_RETRIES,
-    // Pass through untouched: the transport owns case-insensitive merging so
-    // there is exactly one place that decides which header wins.
-    ...options?.headers ? { headers: { ...options.headers } } : {},
-    ...options?.environment ? { environment: options.environment } : {}
-  };
-}
-function mergeProjectEnvFile(filePath, values) {
-  const existing = parseEnvFile(filePath);
-  const merged = mergePersistedEnvValues(existing, values);
-  const dir = dirname(filePath);
-  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
-  ensureProjectEnvIsIgnored(dir);
-  const lines = persistedEnvLines(merged);
-  writeFileSync(filePath, `${lines.join("\n")}
-`, "utf-8");
-}
-function ensureProjectEnvIsIgnored(dir) {
-  ensureProjectPrivatePathsIgnored(dir, [
-    PROJECT_DEEPLINE_ENV_FILE,
-    ".deepline/"
-  ]);
-}
-function ensureProjectPrivatePathsIgnored(dir, entries) {
-  const gitDir = findNearestGitCommonDir(dir);
-  if (gitDir) {
-    const excludePath = join(gitDir, "info", "exclude");
-    const existing2 = existsSync(excludePath) ? readFileSync(excludePath, "utf-8") : "";
-    const existingEntries2 = new Set(
-      existing2.split(/\r?\n/).map((line) => line.trim()).filter(Boolean)
-    );
-    const missing2 = entries.filter(
-      (entry) => !existingEntries2.has(entry) && !existingEntries2.has(`/${entry}`)
-    );
-    if (missing2.length === 0) return;
-    mkdirSync(dirname(excludePath), { recursive: true });
-    const prefix2 = existing2 && !existing2.endsWith("\n") ? "\n" : "";
-    writeFileSync(
-      excludePath,
-      `${existing2}${prefix2}${missing2.join("\n")}
-`,
-      "utf-8"
-    );
-    return;
-  }
-  const gitignorePath = join(dir, ".gitignore");
-  const existing = existsSync(gitignorePath) ? readFileSync(gitignorePath, "utf-8") : "";
-  const existingEntries = new Set(
-    existing.split(/\r?\n/).map((line) => line.trim()).filter(Boolean)
-  );
-  const missing = entries.filter(
-    (entry) => !existingEntries.has(entry) && !existingEntries.has(`/${entry}`)
-  );
-  if (missing.length === 0) return;
-  const prefix = existing && !existing.endsWith("\n") ? "\n" : "";
-  writeFileSync(
-    gitignorePath,
-    `${existing}${prefix}${missing.join("\n")}
-`,
-    "utf-8"
-  );
-}
-function findNearestGitCommonDir(startDir) {
-  let current = resolve(startDir);
-  while (true) {
-    const candidate = join(current, ".git");
-    if (existsSync(candidate)) {
-      try {
-        const stat = statSync(candidate);
-        if (stat.isDirectory()) return candidate;
-        if (stat.isFile()) {
-          const match = readFileSync(candidate, "utf8").match(
-            /^gitdir:\s*(.+)$/m
-          );
-          const rawGitDir = match?.[1]?.trim();
-          if (rawGitDir) {
-            const gitDir = isAbsolute(rawGitDir) ? rawGitDir : resolve(dirname(candidate), rawGitDir);
-            const commonDirPath = join(gitDir, "commondir");
-            if (!existsSync(commonDirPath)) return gitDir;
-            const rawCommonDir = readFileSync(commonDirPath, "utf8").trim();
-            return rawCommonDir ? isAbsolute(rawCommonDir) ? rawCommonDir : resolve(gitDir, rawCommonDir) : gitDir;
-          }
-        }
-      } catch {
-        return null;
-      }
-    }
-    const parent = dirname(current);
-    if (parent === current) return null;
-    current = parent;
-  }
-}
-function saveProjectDeeplineEnvValues(values, startDir = process.cwd()) {
-  const target = resolveProjectPinTarget(startDir);
-  if (!target.ok) {
-    throw new ConfigError(
-      `Cowork project folder is ambiguous. Candidate folders: ${target.candidates.join(
-        ", "
-      )}. Set CLAUDE_PROJECT_DIR or cd into the intended project folder before running this command.`
-    );
-  }
-  const filePath = join(target.dir, PROJECT_DEEPLINE_ENV_FILE);
-  mergeProjectEnvFile(filePath, values);
-  return [filePath];
-}
-function resolveProjectPinTarget(startDir = process.cwd()) {
-  const nearestFile = findNearestEnvFile(PROJECT_DEEPLINE_ENV_FILE, startDir);
-  if (nearestFile && !isInIgnoredCoworkMount(nearestFile)) {
-    return { ok: true, dir: dirname(nearestFile), source: "nearest" };
-  }
-  const coworkCandidates = listCoworkWorkspaceDirCandidates();
-  if (coworkCandidates.length === 1) {
-    return { ok: true, dir: coworkCandidates[0], source: "cowork" };
-  }
-  if (coworkCandidates.length > 1) {
-    const resolvedStartDir = canonicalPath(startDir);
-    const cwdCandidate = coworkCandidates.find((candidate) => {
-      const resolvedCandidate = canonicalPath(candidate);
-      return resolvedStartDir === resolvedCandidate || resolvedStartDir.startsWith(`${resolvedCandidate}/`);
-    });
-    if (cwdCandidate) {
-      return { ok: true, dir: cwdCandidate, source: "cowork" };
-    }
-    return {
-      ok: false,
-      reason: "ambiguous_cowork_project",
-      candidates: coworkCandidates
-    };
-  }
-  return { ok: true, dir: resolve(startDir), source: "cwd" };
-}
-function getActiveProjectAuthSource(startDir = process.cwd()) {
-  return loadProjectEnvCandidates(startDir)[0] ?? null;
-}
-function findNearestProjectMarkerDir(startDir) {
-  let current = resolve(startDir);
-  while (true) {
-    if (COWORK_PROJECT_MARKERS.some((marker) => existsSync(join(current, marker)))) {
-      return current;
-    }
-    const parent = dirname(current);
-    if (parent === current) return null;
-    current = parent;
-  }
-}
-function resolveCliAuthProvenance(config, startDir = process.cwd()) {
-  const envApiKey = process.env[API_KEY_ENV]?.trim();
-  const folderAuth = getResolvedProjectAuthSource(
-    config.baseUrl,
-    config.apiKey,
-    startDir
-  );
-  const pinTarget = resolveProjectPinTarget(startDir);
-  const markerDir = findNearestProjectMarkerDir(startDir);
-  const project = !pinTarget.ok ? {
-    state: "ambiguous_cowork_project",
-    candidates: pinTarget.candidates
-  } : folderAuth ? {
-    state: "project",
-    dir: dirname(folderAuth.filePath),
-    pinPath: folderAuth.filePath,
-    source: "folder"
-  } : pinTarget.source === "cowork" ? {
-    state: "project",
-    dir: pinTarget.dir,
-    pinPath: join(pinTarget.dir, PROJECT_DEEPLINE_ENV_FILE),
-    source: "cowork"
-  } : markerDir ? {
-    state: "project",
-    dir: markerDir,
-    pinPath: join(markerDir, PROJECT_DEEPLINE_ENV_FILE),
-    source: "marker"
-  } : { state: "not_project" };
-  return {
-    scope: envApiKey ? "env" : folderAuth ? "folder" : "global",
-    project,
-    folderAuthPath: folderAuth?.filePath ?? null
-  };
-}
-function activeOrganizationFromEnv(env) {
-  const orgId = env[ACTIVE_ORG_ID_ENV]?.trim();
-  if (!orgId) return null;
-  const orgName = env[ACTIVE_ORG_NAME_ENV]?.trim() || null;
-  return { org_id: orgId, org_name: orgName };
-}
-function resolveCliCommandContext(inputConfig, requestedScope) {
-  let config = inputConfig;
-  if (!config) {
-    try {
-      config = resolveConfig();
-    } catch {
-      return {
-        active_organization: null,
-        auth_scope: null,
-        metadata_source: null
-      };
-    }
-  }
-  const contextForScope = (scope) => {
-    if (scope === "env") {
-      const processApiKey = process.env[API_KEY_ENV]?.trim();
-      return processApiKey && processApiKey === config.apiKey ? {
-        active_organization: activeOrganizationFromEnv(process.env),
-        auth_scope: "env",
-        metadata_source: "process_env"
-      } : null;
-    }
-    if (scope === "folder") {
-      const projectAuth = getResolvedProjectAuthSource(
-        config.baseUrl,
-        config.apiKey
-      );
-      return projectAuth ? {
-        active_organization: activeOrganizationFromEnv(projectAuth.env),
-        auth_scope: "folder",
-        metadata_source: "folder_env"
-      } : null;
-    }
-    const hostEnv = loadCliEnv(config.baseUrl);
-    return (hostEnv[API_KEY_ENV] ?? "").trim() === config.apiKey ? {
-      active_organization: activeOrganizationFromEnv(hostEnv),
-      auth_scope: "global",
-      metadata_source: "host_env"
-    } : null;
-  };
-  const processContext = contextForScope("env");
-  if (processContext) return processContext;
-  if (requestedScope) {
-    return contextForScope(requestedScope) ?? {
-      active_organization: null,
-      auth_scope: requestedScope,
-      metadata_source: null
-    };
-  }
-  for (const scope of ["folder", "global"]) {
-    const context = contextForScope(scope);
-    if (context) return context;
-  }
-  return {
-    active_organization: null,
-    auth_scope: null,
-    metadata_source: null
-  };
-}
+} from "./chunk-XZAFIOUQ.mjs";
 
 // src/version.ts
 var SDK_VERSION = SDK_RELEASE.version;
@@ -654,7 +24,7 @@ var SDK_API_MAJOR = SDK_RELEASE.contracts.api.currentMajor;
 var SDK_API_CONTRACT = SDK_RELEASE.contracts.api.legacyWireIds[0] ?? `api-v${SDK_API_MAJOR}`;
 
 // src/agent-runtime.ts
-import { homedir as homedir2 } from "os";
+import { homedir } from "os";
 var EXPLICIT_AGENT_RUNTIMES = /* @__PURE__ */ new Set([
   "claude_code",
   "claude_cowork",
@@ -694,12 +64,12 @@ function agentSessionIdFromEnvironment(env = process.env, agentRuntime) {
   }
   return null;
 }
-function isCoworkLikeSandbox2() {
+function isCoworkLikeSandbox() {
   const pluginMode = truthyEnv("DEEPLINE_PLUGIN_MODE");
   const claudeRemote = truthyEnv("CLAUDE_CODE_REMOTE");
   const projectDir = Boolean(process.env.CLAUDE_PROJECT_DIR?.trim());
   const pluginRoot = Boolean(process.env.DEEPLINE_PLUGIN_ROOT?.trim());
-  const home = process.env.HOME?.trim() || homedir2();
+  const home = process.env.HOME?.trim() || homedir();
   const sessionHome = home === "/sessions" || home.startsWith("/sessions/");
   return claudeRemote || sessionHome || (pluginMode || pluginRoot) && projectDir;
 }
@@ -708,7 +78,7 @@ function detectAgentRuntime(options = {}) {
   const explicit = normalizeAgentRuntime(env.DEEPLINE_AGENT_RUNTIME);
   if (explicit) return explicit;
   if (env.CODEX_THREAD_ID?.trim()) return "codex";
-  if (options.detectCowork !== false && isCoworkLikeSandbox2()) {
+  if (options.detectCowork !== false && isCoworkLikeSandbox()) {
     return "claude_cowork";
   }
   if (env.CLAUDECODE?.trim() === "1") return "claude_code";
@@ -728,134 +98,6 @@ function detectAgentRuntime(options = {}) {
   return options.defaultRuntime ?? "unknown";
 }
 
-// src/skills-version.ts
-import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
-import { dirname as dirname2, join as join2 } from "path";
-function activePluginSkillsDir() {
-  const pluginMode = process.env.DEEPLINE_PLUGIN_MODE?.trim().toLowerCase();
-  if (pluginMode !== "true" && pluginMode !== "1" && pluginMode !== "yes" && pluginMode !== "on") {
-    return "";
-  }
-  const dir = process.env.DEEPLINE_PLUGIN_SKILLS_DIR?.trim() ?? "";
-  return dir && existsSync2(dir) ? dir : "";
-}
-function hasActivePluginSkills() {
-  return Boolean(activePluginSkillsDir());
-}
-function readPluginSkillsVersion() {
-  const dir = activePluginSkillsDir();
-  if (!dir) return "";
-  try {
-    return readFileSync2(join2(dir, ".version"), "utf-8").trim();
-  } catch {
-    return "";
-  }
-}
-var KNOWN_SKILL_AGENTS = [
-  "antigravity",
-  "claude-code",
-  "cline",
-  "codex",
-  "cursor",
-  "gemini-cli",
-  "windsurf"
-];
-var DEFAULT_SKILL_AGENTS = [
-  "codex",
-  "claude-code",
-  "cursor",
-  "gemini-cli",
-  "antigravity"
-];
-function skillsAgentPathSegment(agent) {
-  if (agent === "*") return "all";
-  const slug = agent.replace(/[^a-z0-9]+/gi, "-").replace(/^-+|-+$/g, "");
-  return slug || "agent";
-}
-function sdkSkillsVersionPath(baseUrl, agents = []) {
-  const suffix = agents.length > 0 ? `-${agents.map(skillsAgentPathSegment).join("-")}` : "";
-  return join2(sdkCliStateDirPath(baseUrl), `skills${suffix}-version`);
-}
-function legacySdkSkillsVersionPath(baseUrl) {
-  return join2(dirname2(sdkCliStateDirPath(baseUrl)), "sdk-skills", ".version");
-}
-function readSkillsVersionFile(path) {
-  try {
-    return readFileSync2(path, "utf-8").trim();
-  } catch {
-    return "";
-  }
-}
-function resolveAutoSyncSkillAgents() {
-  switch (detectAgentRuntime()) {
-    case "codex":
-      return ["codex"];
-    case "claude_code":
-      return ["claude-code"];
-    case "cursor":
-      return ["cursor"];
-    case "gemini":
-      return ["gemini-cli"];
-    case "antigravity":
-      return ["antigravity"];
-    case "unknown":
-      return [...DEFAULT_SKILL_AGENTS];
-    default:
-      return [];
-  }
-}
-function readSdkSkillsLocalVersion(baseUrl) {
-  const pluginVersion = readPluginSkillsVersion();
-  if (pluginVersion) return pluginVersion;
-  const agents = resolveAutoSyncSkillAgents();
-  if (agents.length > 1) {
-    const versions = agents.map(
-      (agent) => readSkillsVersionFile(sdkSkillsVersionPath(baseUrl, [agent]))
-    );
-    const first = versions[0];
-    return first && versions.every((version) => version === first) ? first : "";
-  }
-  const scopedPath = sdkSkillsVersionPath(baseUrl, agents);
-  if (agents.length > 0 && existsSync2(scopedPath)) {
-    try {
-      return readFileSync2(scopedPath, "utf-8").trim();
-    } catch {
-      return "";
-    }
-  }
-  if (agents.length > 0) {
-    const legacyPath = legacySdkSkillsVersionPath(baseUrl);
-    if (!existsSync2(legacyPath)) return "";
-    try {
-      return readFileSync2(legacyPath, "utf-8").trim();
-    } catch {
-      return "";
-    }
-  }
-  const path = existsSync2(sdkSkillsVersionPath(baseUrl)) ? sdkSkillsVersionPath(baseUrl) : legacySdkSkillsVersionPath(baseUrl);
-  if (!existsSync2(path)) return "";
-  try {
-    return readFileSync2(path, "utf-8").trim();
-  } catch {
-    return "";
-  }
-}
-function writeSdkSkillsLocalVersion(baseUrl, version, agents) {
-  const targets = agents.length > 1 ? agents.map((agent) => [agent]) : [agents];
-  let complete = true;
-  for (const target of targets) {
-    const path = sdkSkillsVersionPath(baseUrl, target);
-    try {
-      mkdirSync2(dirname2(path), { recursive: true });
-      writeFileSync2(path, `${version}
-`, "utf-8");
-    } catch {
-      complete = false;
-    }
-  }
-  return complete;
-}
-
 // src/deployment-protection.ts
 function deploymentProtectionHeaders(env = typeof process !== "undefined" ? process.env : {}) {
   const token = env.VERCEL_PROTECTION_BYPASS_TOKEN;
@@ -886,6 +128,7 @@ var SYNTHETIC_RUN_HEADER = "x-deepline-synthetic-run";
 // ../play-runtime/test-runtime-seams.ts
 var PLAY_RUNTIME_TEST_FAULT_HEADER = "x-deepline-test-fault";
 var MAX_RUNTIME_TEST_POLICY_MS = 10 * 6e4;
+var MAX_RUNNER_HEARTBEAT_SILENCE_MS = 10 * 6e4;
 
 // ../integration-contracts/execute-retry-contract.ts
 var EXECUTE_RETRY_POLICY_HEADER = "x-deepline-execute-retry-policy";
@@ -901,7 +144,7 @@ function parseExecuteRetryPolicy(value) {
 }
 var ATOMIC_TOOL_EXECUTE_SUPPORTED_HEADER = "x-deepline-atomic-tool-supported";
 
-// src/http.ts
+// src/http-core.ts
 var MAX_DIAGNOSTIC_HEADER_LENGTH = 120;
 var COWORK_NETWORK_HINT = "Claude Cowork appears to be running Deepline in a network-restricted sandbox. In Claude Desktop, open Settings > Capabilities, turn on Allow network egress, and set Domain allowlist to All domains for the Cowork session.";
 var REQUEST_TIMEOUT_MARKER = Symbol("deeplineRequestTimeout");
@@ -997,8 +240,9 @@ function isRecord(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 var HttpClient = class {
-  constructor(config) {
+  constructor(config, readLocalSkillsVersion) {
     this.config = config;
+    this.readLocalSkillsVersion = readLocalSkillsVersion;
   }
   cleanDiagnosticHeader(value) {
     const normalized = String(value ?? "").replace(/[\u0000-\u001f\u007f]/g, " ").trim().slice(0, MAX_DIAGNOSTIC_HEADER_LENGTH);
@@ -1014,7 +258,7 @@ var HttpClient = class {
     if (explicit) return explicit;
     try {
       return this.cleanDiagnosticHeader(
-        readSdkSkillsLocalVersion(this.config.baseUrl)
+        this.readLocalSkillsVersion?.(this.config.baseUrl)
       );
     } catch {
       return null;
@@ -1635,14 +879,14 @@ function decodeSseFrame(frame) {
   return parsed;
 }
 function sleep(ms, signal) {
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve, reject) => {
     if (signal?.aborted) {
       reject(requestCancelledError(signal));
       return;
     }
     const timeoutId = setTimeout(() => {
       signal?.removeEventListener("abort", abort);
-      resolve2();
+      resolve();
     }, ms);
     const abort = () => {
       clearTimeout(timeoutId);
@@ -1653,7 +897,7 @@ function sleep(ms, signal) {
   });
 }
 function withCoworkNetworkHint(message) {
-  if (!isCoworkLikeSandbox2() || message.includes(COWORK_NETWORK_HINT)) {
+  if (!isCoworkLikeSandbox() || message.includes(COWORK_NETWORK_HINT)) {
     return message;
   }
   return `${message}
@@ -1661,50 +905,16 @@ ${COWORK_NETWORK_HINT}`;
 }
 
 export {
-  HOST_URL_ENV,
-  API_KEY_ENV,
-  ACTIVE_ORG_ID_ENV,
-  ACTIVE_ORG_NAME_ENV,
-  FEATURES_ENV,
-  PROD_URL,
-  featureEnvValues,
-  storedHostApiKey,
-  storedHostFeatures,
-  baseUrlSlug,
-  sdkCliStateDirPath,
-  hostConfigDirPath,
-  hostEnvFilePath,
-  saveHostEnvValues,
-  autoDetectBaseUrl,
-  resolveApiKeyForBaseUrl,
-  resolveProjectApiKeyForBaseUrl,
-  resolveGlobalApiKeyForBaseUrl,
-  getResolvedProjectAuthSource,
-  resolveBaseUrlOnly,
-  resolveConfig,
-  ensureProjectPrivatePathsIgnored,
-  saveProjectDeeplineEnvValues,
-  resolveProjectPinTarget,
-  getActiveProjectAuthSource,
-  resolveCliAuthProvenance,
-  resolveCliCommandContext,
   ATOMIC_TOOL_EXECUTE_SUPPORTED_HEADER,
   SDK_VERSION,
   SDK_API_MAJOR,
   SDK_API_CONTRACT,
+  COORDINATOR_INTERNAL_TOKEN_HEADER,
+  RUNTIME_ENVIRONMENT_TOKEN_HEADER,
+  RETAINED_PIPELINE_RECEIVERS_HEADER,
   agentSessionIdFromEnvironment,
   detectAgentRuntime,
-  hasActivePluginSkills,
-  KNOWN_SKILL_AGENTS,
-  DEFAULT_SKILL_AGENTS,
-  skillsAgentPathSegment,
-  resolveAutoSyncSkillAgents,
-  readSdkSkillsLocalVersion,
-  writeSdkSkillsLocalVersion,
   deploymentProtectionHeaders,
   fetchWithDeploymentProtection,
-  COORDINATOR_INTERNAL_TOKEN_HEADER,
-  RUNTIME_ENVIRONMENT_TOKEN_HEADER,
-  RETAINED_PIPELINE_RECEIVERS_HEADER,
   HttpClient
 };