deepline 0.3.461 → 0.3.462

package/dist/cli/chunk-Y4DPU4OM.js

@@ -0,0 +1,827 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+
+var _chunkYT5EODJOjs = require('./chunk-YT5EODJO.js');
+
+
+var _chunkALJJRZNJjs = require('./chunk-ALJJRZNJ.js');
+
+// src/config.ts
+
+
+
+
+
+
+
+
+var _fs = require('fs');
+var _os = require('os');
+var _path = require('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 _nullishCoalesce(loadCliEnv(normalizeBaseUrl(baseUrl) || baseUrl)[API_KEY_ENV], () => ( ""));
+}
+function storedHostFeatures(baseUrl) {
+  return loadCliEnv(normalizeBaseUrl(baseUrl) || baseUrl)[FEATURES_ENV];
+}
+function envHasFeature(env, feature) {
+  return (_nullishCoalesce(env[FEATURES_ENV], () => ( ""))).split(",").map((key) => key.trim()).includes(feature);
+}
+function cliFeatureEnabled(feature) {
+  const processEnv = process.env;
+  if (envHasFeature(processEnv, feature)) return true;
+  if (_optionalChain([processEnv, 'access', _ => _[API_KEY_ENV], 'optionalAccess', _2 => _2.trim, 'call', _3 => _3()])) return false;
+  try {
+    const baseUrl = resolveBaseUrlOnly();
+    const projectEnv = loadProjectEnvCandidates().find(
+      ({ env }) => normalizeBaseUrl(_nullishCoalesce(env[HOST_URL_ENV], () => ( ""))) === baseUrl && Boolean(env[API_KEY_ENV])
+    );
+    return envHasFeature(_nullishCoalesce(_optionalChain([projectEnv, 'optionalAccess', _4 => _4.env]), () => ( loadCliEnv(baseUrl))), feature);
+  } catch (e) {
+    return false;
+  }
+}
+function baseUrlSlug(baseUrl) {
+  let url;
+  try {
+    url = new URL(baseUrl);
+  } catch (e2) {
+    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 (!_fs.existsSync.call(void 0, filePath)) return {};
+  const env = {};
+  const content = _fs.readFileSync.call(void 0, 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 (e3) {
+        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 = _path.resolve.call(void 0, startDir);
+  while (true) {
+    const filePath = _path.join.call(void 0, current, name);
+    if (_fs.existsSync.call(void 0, filePath)) return filePath;
+    const parent = _path.dirname.call(void 0, current);
+    if (parent === current) return null;
+    current = parent;
+  }
+}
+function isDirectory(path) {
+  try {
+    return _fs.statSync.call(void 0, path).isDirectory();
+  } catch (e4) {
+    return false;
+  }
+}
+function canonicalPath(path) {
+  try {
+    return _fs.realpathSync.call(void 0, path);
+  } catch (e5) {
+    return _path.resolve.call(void 0, path);
+  }
+}
+function isTruthy(value) {
+  return /^(1|true|yes|on)$/i.test(_nullishCoalesce(_optionalChain([value, 'optionalAccess', _5 => _5.trim, 'call', _6 => _6()]), () => ( "")));
+}
+function sessionRootFromPath(path) {
+  const trimmed = _optionalChain([path, 'optionalAccess', _7 => _7.trim, 'call', _8 => _8()]);
+  if (!trimmed) return null;
+  const match = /^\/sessions\/[^/]+(?=\/|$)/.exec(trimmed);
+  return _nullishCoalesce(_optionalChain([match, 'optionalAccess', _9 => _9[0]]), () => ( null));
+}
+function coworkSessionRoot() {
+  const home = _optionalChain([process, 'access', _10 => _10.env, 'access', _11 => _11.HOME, 'optionalAccess', _12 => _12.trim, 'call', _13 => _13()]);
+  const homeSessionRoot = sessionRootFromPath(home);
+  if (homeSessionRoot && isDirectory(_path.join.call(void 0, homeSessionRoot, "mnt"))) {
+    return homeSessionRoot;
+  }
+  const cwdSessionRoot = sessionRootFromPath(process.cwd());
+  if (cwdSessionRoot && isDirectory(_path.join.call(void 0, cwdSessionRoot, "mnt"))) {
+    return cwdSessionRoot;
+  }
+  if (isTruthy(process.env.CLAUDE_CODE_REMOTE) && home) {
+    const mountedRoot = _path.join.call(void 0, home, "mnt");
+    if (isDirectory(mountedRoot)) return _path.resolve.call(void 0, home);
+  }
+  return null;
+}
+function isCoworkLikeSandbox() {
+  const home = _optionalChain([process, 'access', _14 => _14.env, 'access', _15 => _15.HOME, 'optionalAccess', _16 => _16.trim, 'call', _17 => _17()]);
+  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 (_fs.existsSync.call(void 0, _path.join.call(void 0, path, marker))) score += 1;
+  }
+  return score;
+}
+function listCoworkWorkspaceDirCandidates() {
+  if (!isCoworkLikeSandbox()) {
+    return [];
+  }
+  const explicitProjectDir = _optionalChain([process, 'access', _18 => _18.env, 'access', _19 => _19.CLAUDE_PROJECT_DIR, 'optionalAccess', _20 => _20.trim, 'call', _21 => _21()]);
+  if (explicitProjectDir && isDirectory(explicitProjectDir)) {
+    return [_path.resolve.call(void 0, explicitProjectDir)];
+  }
+  const sessionRoot = coworkSessionRoot();
+  if (!sessionRoot) return [];
+  const mountedRoot = _path.join.call(void 0, sessionRoot, "mnt");
+  if (!isDirectory(mountedRoot)) return [];
+  let names;
+  try {
+    names = _fs.readdirSync.call(void 0, mountedRoot).sort();
+  } catch (e6) {
+    return [];
+  }
+  const candidates = [];
+  for (const name of names) {
+    if (name.startsWith(".") || COWORK_IGNORED_WORKSPACE_DIRS.has(name)) {
+      continue;
+    }
+    const candidate = _path.join.call(void 0, 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(_path.join.call(void 0, 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(_path.resolve.call(void 0, nearestFile), "nearest");
+  }
+  const coworkWorkspaceDir = detectCoworkWorkspaceDir();
+  if (coworkWorkspaceDir) {
+    const coworkFile = _path.join.call(void 0, coworkWorkspaceDir, PROJECT_DEEPLINE_ENV_FILE);
+    if (_fs.existsSync.call(void 0, coworkFile) && !filePaths.some((filePath) => _path.resolve.call(void 0, filePath) === _path.resolve.call(void 0, coworkFile))) {
+      filePaths.push(coworkFile);
+      sources.set(_path.resolve.call(void 0, coworkFile), "cowork");
+    }
+  }
+  return filePaths.map((filePath) => ({
+    filePath,
+    env: parseEnvFile(filePath),
+    source: _nullishCoalesce(sources.get(_path.resolve.call(void 0, filePath)), () => ( "nearest"))
+  }));
+}
+function normalizeBaseUrl(baseUrl) {
+  const trimmed = _nullishCoalesce(_optionalChain([baseUrl, 'optionalAccess', _22 => _22.trim, 'call', _23 => _23(), 'access', _24 => _24.replace, 'call', _25 => _25(/\/+$/, "")]), () => ( ""));
+  if (!trimmed) return "";
+  try {
+    const parsed = new URL(trimmed);
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+      return "";
+    }
+    return parsed.toString().replace(/\/+$/, "");
+  } catch (e7) {
+    return "";
+  }
+}
+function firstNonEmpty(...values) {
+  for (const value of values) {
+    const trimmed = _optionalChain([value, 'optionalAccess', _26 => _26.trim, 'call', _27 => _27()]);
+    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 = _optionalChain([process, 'access', _28 => _28.env, 'access', _29 => _29.HOME, 'optionalAccess', _30 => _30.trim, 'call', _31 => _31()]) || _os.homedir.call(void 0, );
+  return _path.join.call(void 0, home, ".local", "deepline", baseUrlSlug(baseUrl || PROD_URL));
+}
+function sdkCliStateDirPath(baseUrl, homeDir = _optionalChain([process, 'access', _32 => _32.env, 'access', _33 => _33.HOME, 'optionalAccess', _34 => _34.trim, 'call', _35 => _35()]) || _os.homedir.call(void 0, )) {
+  return _path.join.call(void 0, 
+    homeDir,
+    ".local",
+    "deepline",
+    baseUrlSlug(baseUrl || PROD_URL),
+    "sdk-cli"
+  );
+}
+function sdkCliEnvFilePath(baseUrl) {
+  return _path.join.call(void 0, 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 = _path.dirname.call(void 0, filePath);
+  if (!_fs.existsSync.call(void 0, dir)) {
+    _fs.mkdirSync.call(void 0, dir, { recursive: true });
+  }
+  const existing = parseEnvFile(filePath);
+  const merged = mergePersistedEnvValues(existing, values);
+  const lines = persistedEnvLines(merged);
+  _fs.writeFileSync.call(void 0, filePath, `${lines.join("\n")}
+`, "utf-8");
+}
+function loadGlobalCliEnv() {
+  return loadCliEnv(PROD_URL);
+}
+function autoDetectBaseUrl() {
+  const projectEnvs = loadProjectEnvCandidates();
+  const globalEnv = loadGlobalCliEnv();
+  return normalizeBaseUrl(_nullishCoalesce(process.env[HOST_URL_ENV], () => ( ""))) || firstNonEmpty(
+    ...projectEnvs.map(({ env }) => normalizeBaseUrl(env[HOST_URL_ENV]))
+  ) || normalizeBaseUrl(_nullishCoalesce(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(_nullishCoalesce(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(_nullishCoalesce(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 _nullishCoalesce(loadProjectEnvCandidates(startDir).find(({ env }) => {
+    const projectBaseUrl = normalizeBaseUrl(_nullishCoalesce(env[HOST_URL_ENV], () => ( "")));
+    return projectBaseUrl === normalizedBaseUrl && (_nullishCoalesce(env[API_KEY_ENV], () => ( ""))).trim() === normalizedApiKey;
+  }), () => ( null));
+}
+function resolveBaseUrlOnly(options) {
+  const baseUrl = normalizeBaseUrl(
+    _optionalChain([options, 'optionalAccess', _36 => _36.baseUrl, 'optionalAccess', _37 => _37.trim, 'call', _38 => _38()]) || autoDetectBaseUrl()
+  );
+  if (!baseUrl) {
+    throw new (0, _chunkALJJRZNJjs.ConfigError)(
+      `Invalid ${HOST_URL_ENV}. Expected an http(s) URL such as https://code.deepline.com.`
+    );
+  }
+  return baseUrl;
+}
+function resolveConfig(options) {
+  const baseUrl = normalizeBaseUrl(
+    _optionalChain([options, 'optionalAccess', _39 => _39.baseUrl, 'optionalAccess', _40 => _40.trim, 'call', _41 => _41()]) || autoDetectBaseUrl()
+  );
+  if (!baseUrl) {
+    throw new (0, _chunkALJJRZNJjs.ConfigError)(
+      `Invalid ${HOST_URL_ENV}. Expected an http(s) URL such as https://code.deepline.com.`
+    );
+  }
+  const apiKey = resolveApiKeyForBaseUrl(baseUrl, _optionalChain([options, 'optionalAccess', _42 => _42.apiKey]));
+  if (!apiKey) {
+    throw new (0, _chunkALJJRZNJjs.ConfigError)(
+      `No API key found. Set ${API_KEY_ENV}, add it to .env.deepline, or run: deepline auth register`
+    );
+  }
+  return {
+    apiKey,
+    baseUrl,
+    timeout: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _43 => _43.timeout]), () => ( DEFAULT_TIMEOUT)),
+    maxRetries: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _44 => _44.maxRetries]), () => ( DEFAULT_MAX_RETRIES)),
+    // Pass through untouched: the transport owns case-insensitive merging so
+    // there is exactly one place that decides which header wins.
+    ..._optionalChain([options, 'optionalAccess', _45 => _45.headers]) ? { headers: { ...options.headers } } : {},
+    ..._optionalChain([options, 'optionalAccess', _46 => _46.environment]) ? { environment: options.environment } : {}
+  };
+}
+function mergeProjectEnvFile(filePath, values) {
+  const existing = parseEnvFile(filePath);
+  const merged = mergePersistedEnvValues(existing, values);
+  const dir = _path.dirname.call(void 0, filePath);
+  if (!_fs.existsSync.call(void 0, dir)) _fs.mkdirSync.call(void 0, dir, { recursive: true });
+  ensureProjectEnvIsIgnored(dir);
+  const lines = persistedEnvLines(merged);
+  _fs.writeFileSync.call(void 0, 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 = _path.join.call(void 0, gitDir, "info", "exclude");
+    const existing2 = _fs.existsSync.call(void 0, excludePath) ? _fs.readFileSync.call(void 0, 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;
+    _fs.mkdirSync.call(void 0, _path.dirname.call(void 0, excludePath), { recursive: true });
+    const prefix2 = existing2 && !existing2.endsWith("\n") ? "\n" : "";
+    _fs.writeFileSync.call(void 0, 
+      excludePath,
+      `${existing2}${prefix2}${missing2.join("\n")}
+`,
+      "utf-8"
+    );
+    return;
+  }
+  const gitignorePath = _path.join.call(void 0, dir, ".gitignore");
+  const existing = _fs.existsSync.call(void 0, gitignorePath) ? _fs.readFileSync.call(void 0, 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" : "";
+  _fs.writeFileSync.call(void 0, 
+    gitignorePath,
+    `${existing}${prefix}${missing.join("\n")}
+`,
+    "utf-8"
+  );
+}
+function findNearestGitCommonDir(startDir) {
+  let current = _path.resolve.call(void 0, startDir);
+  while (true) {
+    const candidate = _path.join.call(void 0, current, ".git");
+    if (_fs.existsSync.call(void 0, candidate)) {
+      try {
+        const stat = _fs.statSync.call(void 0, candidate);
+        if (stat.isDirectory()) return candidate;
+        if (stat.isFile()) {
+          const match = _fs.readFileSync.call(void 0, candidate, "utf8").match(
+            /^gitdir:\s*(.+)$/m
+          );
+          const rawGitDir = _optionalChain([match, 'optionalAccess', _47 => _47[1], 'optionalAccess', _48 => _48.trim, 'call', _49 => _49()]);
+          if (rawGitDir) {
+            const gitDir = _path.isAbsolute.call(void 0, rawGitDir) ? rawGitDir : _path.resolve.call(void 0, _path.dirname.call(void 0, candidate), rawGitDir);
+            const commonDirPath = _path.join.call(void 0, gitDir, "commondir");
+            if (!_fs.existsSync.call(void 0, commonDirPath)) return gitDir;
+            const rawCommonDir = _fs.readFileSync.call(void 0, commonDirPath, "utf8").trim();
+            return rawCommonDir ? _path.isAbsolute.call(void 0, rawCommonDir) ? rawCommonDir : _path.resolve.call(void 0, gitDir, rawCommonDir) : gitDir;
+          }
+        }
+      } catch (e8) {
+        return null;
+      }
+    }
+    const parent = _path.dirname.call(void 0, current);
+    if (parent === current) return null;
+    current = parent;
+  }
+}
+function saveProjectDeeplineEnvValues(values, startDir = process.cwd()) {
+  const target = resolveProjectPinTarget(startDir);
+  if (!target.ok) {
+    throw new (0, _chunkALJJRZNJjs.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 = _path.join.call(void 0, 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: _path.dirname.call(void 0, 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: _path.resolve.call(void 0, startDir), source: "cwd" };
+}
+function getActiveProjectAuthSource(startDir = process.cwd()) {
+  return _nullishCoalesce(loadProjectEnvCandidates(startDir)[0], () => ( null));
+}
+function findNearestProjectMarkerDir(startDir) {
+  let current = _path.resolve.call(void 0, startDir);
+  while (true) {
+    if (COWORK_PROJECT_MARKERS.some((marker) => _fs.existsSync.call(void 0, _path.join.call(void 0, current, marker)))) {
+      return current;
+    }
+    const parent = _path.dirname.call(void 0, current);
+    if (parent === current) return null;
+    current = parent;
+  }
+}
+function resolveCliAuthProvenance(config, startDir = process.cwd()) {
+  const envApiKey = _optionalChain([process, 'access', _50 => _50.env, 'access', _51 => _51[API_KEY_ENV], 'optionalAccess', _52 => _52.trim, 'call', _53 => _53()]);
+  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: _path.dirname.call(void 0, folderAuth.filePath),
+    pinPath: folderAuth.filePath,
+    source: "folder"
+  } : pinTarget.source === "cowork" ? {
+    state: "project",
+    dir: pinTarget.dir,
+    pinPath: _path.join.call(void 0, pinTarget.dir, PROJECT_DEEPLINE_ENV_FILE),
+    source: "cowork"
+  } : markerDir ? {
+    state: "project",
+    dir: markerDir,
+    pinPath: _path.join.call(void 0, markerDir, PROJECT_DEEPLINE_ENV_FILE),
+    source: "marker"
+  } : { state: "not_project" };
+  return {
+    scope: envApiKey ? "env" : folderAuth ? "folder" : "global",
+    project,
+    folderAuthPath: _nullishCoalesce(_optionalChain([folderAuth, 'optionalAccess', _54 => _54.filePath]), () => ( null))
+  };
+}
+function activeOrganizationFromEnv(env) {
+  const orgId = _optionalChain([env, 'access', _55 => _55[ACTIVE_ORG_ID_ENV], 'optionalAccess', _56 => _56.trim, 'call', _57 => _57()]);
+  if (!orgId) return null;
+  const orgName = _optionalChain([env, 'access', _58 => _58[ACTIVE_ORG_NAME_ENV], 'optionalAccess', _59 => _59.trim, 'call', _60 => _60()]) || null;
+  return { org_id: orgId, org_name: orgName };
+}
+function resolveCliCommandContext(inputConfig, requestedScope) {
+  let config = inputConfig;
+  if (!config) {
+    try {
+      config = resolveConfig();
+    } catch (e9) {
+      return {
+        active_organization: null,
+        auth_scope: null,
+        metadata_source: null
+      };
+    }
+  }
+  const contextForScope = (scope) => {
+    if (scope === "env") {
+      const processApiKey = _optionalChain([process, 'access', _61 => _61.env, 'access', _62 => _62[API_KEY_ENV], 'optionalAccess', _63 => _63.trim, 'call', _64 => _64()]);
+      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 (_nullishCoalesce(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 _nullishCoalesce(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
+  };
+}
+
+// src/skills-version.ts
+
+
+function activePluginSkillsDir() {
+  const pluginMode = _optionalChain([process, 'access', _65 => _65.env, 'access', _66 => _66.DEEPLINE_PLUGIN_MODE, 'optionalAccess', _67 => _67.trim, 'call', _68 => _68(), 'access', _69 => _69.toLowerCase, 'call', _70 => _70()]);
+  if (pluginMode !== "true" && pluginMode !== "1" && pluginMode !== "yes" && pluginMode !== "on") {
+    return "";
+  }
+  const dir = _nullishCoalesce(_optionalChain([process, 'access', _71 => _71.env, 'access', _72 => _72.DEEPLINE_PLUGIN_SKILLS_DIR, 'optionalAccess', _73 => _73.trim, 'call', _74 => _74()]), () => ( ""));
+  return dir && _fs.existsSync.call(void 0, dir) ? dir : "";
+}
+function hasActivePluginSkills() {
+  return Boolean(activePluginSkillsDir());
+}
+function readPluginSkillsVersion() {
+  const dir = activePluginSkillsDir();
+  if (!dir) return "";
+  try {
+    return _fs.readFileSync.call(void 0, _path.join.call(void 0, dir, ".version"), "utf-8").trim();
+  } catch (e10) {
+    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 _path.join.call(void 0, sdkCliStateDirPath(baseUrl), `skills${suffix}-version`);
+}
+function legacySdkSkillsVersionPath(baseUrl) {
+  return _path.join.call(void 0, _path.dirname.call(void 0, sdkCliStateDirPath(baseUrl)), "sdk-skills", ".version");
+}
+function readSkillsVersionFile(path) {
+  try {
+    return _fs.readFileSync.call(void 0, path, "utf-8").trim();
+  } catch (e11) {
+    return "";
+  }
+}
+function resolveAutoSyncSkillAgents() {
+  switch (_chunkYT5EODJOjs.detectAgentRuntime.call(void 0, )) {
+    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 && _fs.existsSync.call(void 0, scopedPath)) {
+    try {
+      return _fs.readFileSync.call(void 0, scopedPath, "utf-8").trim();
+    } catch (e12) {
+      return "";
+    }
+  }
+  if (agents.length > 0) {
+    const legacyPath = legacySdkSkillsVersionPath(baseUrl);
+    if (!_fs.existsSync.call(void 0, legacyPath)) return "";
+    try {
+      return _fs.readFileSync.call(void 0, legacyPath, "utf-8").trim();
+    } catch (e13) {
+      return "";
+    }
+  }
+  const path = _fs.existsSync.call(void 0, sdkSkillsVersionPath(baseUrl)) ? sdkSkillsVersionPath(baseUrl) : legacySdkSkillsVersionPath(baseUrl);
+  if (!_fs.existsSync.call(void 0, path)) return "";
+  try {
+    return _fs.readFileSync.call(void 0, path, "utf-8").trim();
+  } catch (e14) {
+    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 {
+      _fs.mkdirSync.call(void 0, _path.dirname.call(void 0, path), { recursive: true });
+      _fs.writeFileSync.call(void 0, path, `${version}
+`, "utf-8");
+    } catch (e15) {
+      complete = false;
+    }
+  }
+  return complete;
+}
+
+// src/http.ts
+var HttpClient2 = class extends _chunkYT5EODJOjs.HttpClient {
+  constructor(config) {
+    super(config, readSdkSkillsLocalVersion);
+  }
+};
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.HOST_URL_ENV = HOST_URL_ENV; exports.API_KEY_ENV = API_KEY_ENV; exports.ACTIVE_ORG_ID_ENV = ACTIVE_ORG_ID_ENV; exports.ACTIVE_ORG_NAME_ENV = ACTIVE_ORG_NAME_ENV; exports.FEATURES_ENV = FEATURES_ENV; exports.PROD_URL = PROD_URL; exports.featureEnvValues = featureEnvValues; exports.storedHostApiKey = storedHostApiKey; exports.storedHostFeatures = storedHostFeatures; exports.cliFeatureEnabled = cliFeatureEnabled; exports.baseUrlSlug = baseUrlSlug; exports.sdkCliStateDirPath = sdkCliStateDirPath; exports.hostConfigDirPath = hostConfigDirPath; exports.hostEnvFilePath = hostEnvFilePath; exports.saveHostEnvValues = saveHostEnvValues; exports.autoDetectBaseUrl = autoDetectBaseUrl; exports.resolveApiKeyForBaseUrl = resolveApiKeyForBaseUrl; exports.resolveProjectApiKeyForBaseUrl = resolveProjectApiKeyForBaseUrl; exports.resolveGlobalApiKeyForBaseUrl = resolveGlobalApiKeyForBaseUrl; exports.getResolvedProjectAuthSource = getResolvedProjectAuthSource; exports.resolveBaseUrlOnly = resolveBaseUrlOnly; exports.resolveConfig = resolveConfig; exports.ensureProjectPrivatePathsIgnored = ensureProjectPrivatePathsIgnored; exports.saveProjectDeeplineEnvValues = saveProjectDeeplineEnvValues; exports.resolveProjectPinTarget = resolveProjectPinTarget; exports.getActiveProjectAuthSource = getActiveProjectAuthSource; exports.resolveCliAuthProvenance = resolveCliAuthProvenance; exports.resolveCliCommandContext = resolveCliCommandContext; exports.hasActivePluginSkills = hasActivePluginSkills; exports.KNOWN_SKILL_AGENTS = KNOWN_SKILL_AGENTS; exports.DEFAULT_SKILL_AGENTS = DEFAULT_SKILL_AGENTS; exports.skillsAgentPathSegment = skillsAgentPathSegment; exports.resolveAutoSyncSkillAgents = resolveAutoSyncSkillAgents; exports.readSdkSkillsLocalVersion = readSdkSkillsLocalVersion; exports.writeSdkSkillsLocalVersion = writeSdkSkillsLocalVersion; exports.HttpClient = HttpClient2;