deepline 0.1.143 → 0.1.144

package/README.md

@@ -65,8 +65,8 @@ Do not route the SDK CLI through `.env`, `.env.local`, or `.env.worktree`.
 Config resolution order:
 
 ```text
-host: explicit SDK option -> DEEPLINE_HOST_URL -> nearest .env.deepline -> saved production auth -> https://code.deepline.com
-key:  explicit SDK option -> DEEPLINE_API_KEY -> matching nearest .env.deepline -> saved auth for the resolved host
+host: explicit SDK option -> DEEPLINE_HOST_URL -> nearest .env.deepline -> Cowork workspace .env.deepline -> saved production auth -> https://code.deepline.com
+key:  explicit SDK option -> DEEPLINE_API_KEY -> matching nearest .env.deepline -> matching Cowork workspace .env.deepline -> saved auth for the resolved host
 ```
 
 ## CLI commands

package/dist/bundling-sources/sdk/src/config.ts

@@ -15,21 +15,31 @@
  * 1. `options.baseUrl`
  * 2. `DEEPLINE_HOST_URL`
  * 3. nearest project `.env.deepline`
- * 4. production host auth file
- * 5. production fallback: `https://code.deepline.com`
+ * 4. Cowork mounted workspace `.env.deepline`
+ * 5. production host auth file
+ * 6. production fallback: `https://code.deepline.com`
  *
  * API key:
  * 1. `options.apiKey`
  * 2. `DEEPLINE_API_KEY`
  * 3. nearest project `.env.deepline`
- * 4. host auth file for the resolved base URL
+ * 4. Cowork mounted workspace `.env.deepline`
+ * 5. host auth file for the resolved base URL
  *
  * App/runtime env files such as `.env`, `.env.local`, and `.env.worktree` do
  * not route the SDK CLI. Put CLI routing in `.env.deepline`.
  *
  * @module
  */
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import {
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  realpathSync,
+  readFileSync,
+  statSync,
+  writeFileSync,
+} from 'node:fs';
 import { homedir } from 'node:os';
 import { dirname, join, resolve } from 'node:path';
 import type { DeeplineClientOptions, ResolvedConfig } from './types.js';
@@ -48,8 +58,41 @@ const DEFAULT_TIMEOUT = 60_000;
 const DEFAULT_MAX_RETRIES = 3;
 
 const PROJECT_DEEPLINE_ENV_FILE = '.env.deepline';
+const COWORK_IGNORED_WORKSPACE_DIRS = new Set([
+  '.auto-memory',
+  '.claude',
+  '.remote-plugins',
+  'outputs',
+  'plugins',
+  'uploads',
+]);
+const COWORK_PROJECT_MARKERS = [
+  '.deepline',
+  '.env.deepline',
+  '.git',
+  'AGENTS.md',
+  'package.json',
+  'pyproject.toml',
+];
 
 type EnvValues = Record<string, string>;
+type ProjectEnvCandidate = {
+  filePath: string;
+  env: EnvValues;
+  source: 'nearest' | 'cowork';
+};
+export type ProjectAuthSource = ProjectEnvCandidate;
+export type ProjectPinTarget =
+  | {
+      ok: true;
+      dir: string;
+      source: 'nearest' | 'cowork' | 'cwd';
+    }
+  | {
+      ok: false;
+      reason: 'ambiguous_cowork_project';
+      candidates: string[];
+    };
 
 /**
  * Convert a base URL to a filesystem-safe slug for per-host config storage.
@@ -119,9 +162,161 @@ function findNearestEnvFile(
   }
 }
 
+function isDirectory(path: string): boolean {
+  try {
+    return statSync(path).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+function canonicalPath(path: string): string {
+  try {
+    return realpathSync(path);
+  } catch {
+    return resolve(path);
+  }
+}
+
+function isTruthy(value: string | undefined): boolean {
+  return /^(1|true|yes|on)$/i.test(value?.trim() ?? '');
+}
+
+function sessionRootFromPath(path: string | undefined): string | null {
+  const trimmed = path?.trim();
+  if (!trimmed) return null;
+  const match = /^\/sessions\/[^/]+(?=\/|$)/.exec(trimmed);
+  return match?.[0] ?? null;
+}
+
+function coworkSessionRoot(): string | null {
+  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(): boolean {
+  const home = process.env.HOME?.trim();
+  return (
+    isTruthy(process.env.CLAUDE_CODE_REMOTE) ||
+    sessionRootFromPath(home) !== null ||
+    sessionRootFromPath(process.cwd()) !== null
+  );
+}
+
+function coworkProjectScore(path: string): number {
+  let score = 0;
+  for (const marker of COWORK_PROJECT_MARKERS) {
+    if (existsSync(join(path, marker))) score += 1;
+  }
+  return score;
+}
+
+function listCoworkWorkspaceDirCandidates(): string[] {
+  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: string[];
+  try {
+    names = readdirSync(mountedRoot).sort();
+  } catch {
+    return [];
+  }
+
+  const candidates: string[] = [];
+  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: string): boolean {
+  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(): string | null {
+  const candidates = listCoworkWorkspaceDirCandidates();
+  return candidates.length === 1 ? candidates[0] : null;
+}
+
+function loadProjectEnvCandidates(
+  startDir: string = process.cwd(),
+): ProjectEnvCandidate[] {
+  const filePaths: string[] = [];
+  const sources = new Map<string, ProjectEnvCandidate['source']>();
+  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 loadProjectDeeplineEnv(startDir = process.cwd()): EnvValues {
-  const filePath = findNearestEnvFile(PROJECT_DEEPLINE_ENV_FILE, startDir);
-  return filePath ? parseEnvFile(filePath) : {};
+  return loadProjectEnvCandidates(startDir)[0]?.env ?? {};
 }
 
 function normalizeBaseUrl(baseUrl: string): string {
@@ -204,11 +399,13 @@ function loadGlobalCliEnv(): EnvValues {
  * Auto-detect the best base URL when none is explicitly provided.
  */
 function autoDetectBaseUrl(): string {
-  const projectEnv = loadProjectDeeplineEnv();
+  const projectEnvs = loadProjectEnvCandidates();
   const globalEnv = loadGlobalCliEnv();
   return (
     normalizeBaseUrl(process.env[HOST_URL_ENV] ?? '') ||
-    normalizeBaseUrl(projectEnv[HOST_URL_ENV] ?? '') ||
+    firstNonEmpty(
+      ...projectEnvs.map(({ env }) => normalizeBaseUrl(env[HOST_URL_ENV])),
+    ) ||
     normalizeBaseUrl(globalEnv[HOST_URL_ENV] ?? '') ||
     PROD_URL
   );
@@ -219,18 +416,38 @@ export function resolveApiKeyForBaseUrl(
   explicitApiKey?: string | null,
 ): string {
   const normalizedBaseUrl = normalizeBaseUrl(baseUrl);
-  const projectEnv = loadProjectDeeplineEnv();
+  const projectEnvs = loadProjectEnvCandidates();
   const cliEnv = loadCliEnv(normalizedBaseUrl || baseUrl);
-  const projectBaseUrl = normalizeBaseUrl(projectEnv[HOST_URL_ENV] ?? '');
-  const projectKeyApplies = projectBaseUrl === normalizedBaseUrl;
   return firstNonEmpty(
     explicitApiKey,
     process.env[API_KEY_ENV],
-    projectKeyApplies ? projectEnv[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 getResolvedProjectAuthSource(
+  baseUrl: string,
+  apiKey: string,
+  startDir: string = process.cwd(),
+): ProjectAuthSource | null {
+  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
+  );
+}
+
 /**
  * Resolve SDK configuration from the public SDK CLI env contract.
  */
@@ -265,6 +482,7 @@ function mergeProjectEnvFile(filePath: string, values: EnvValues): void {
   const merged = { ...existing, ...values };
   const dir = dirname(filePath);
   if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  ensureProjectEnvIsIgnored(dir);
   const allowedKeys = new Set([HOST_URL_ENV, API_KEY_ENV]);
   const lines = Object.entries(merged)
     .filter(([key, value]) => allowedKeys.has(key) && value !== '')
@@ -272,20 +490,99 @@ function mergeProjectEnvFile(filePath: string, values: EnvValues): void {
   writeFileSync(filePath, `${lines.join('\n')}\n`, 'utf-8');
 }
 
+function ensureProjectEnvIsIgnored(dir: string): void {
+  const gitignorePath = join(dir, '.gitignore');
+  const entry = PROJECT_DEEPLINE_ENV_FILE;
+  const existing = existsSync(gitignorePath)
+    ? readFileSync(gitignorePath, 'utf-8')
+    : '';
+  const alreadyIgnored = existing
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .some((line) => line === entry || line === `/${entry}`);
+  if (alreadyIgnored) return;
+  const prefix = existing && !existing.endsWith('\n') ? '\n' : '';
+  writeFileSync(gitignorePath, `${existing}${prefix}${entry}\n`, 'utf-8');
+}
+
 export function saveProjectDeeplineEnvValues(
   values: EnvValues,
   startDir: string = process.cwd(),
 ): string[] {
-  const filePath = join(resolve(startDir), PROJECT_DEEPLINE_ENV_FILE);
+  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];
 }
 
+export function resolveProjectPinDir(startDir: string = process.cwd()): string {
+  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.`,
+    );
+  }
+  return target.dir;
+}
+
+export function resolveProjectPinTarget(
+  startDir: string = process.cwd(),
+): ProjectPinTarget {
+  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' };
+}
+
+export function getActiveProjectAuthSource(
+  startDir: string = process.cwd(),
+): ProjectAuthSource | null {
+  return loadProjectEnvCandidates(startDir)[0] ?? null;
+}
+
 export {
   baseUrlSlug,
   loadCliEnv,
   loadGlobalCliEnv,
+  loadProjectDeeplineEnv,
+  getResolvedProjectAuthSource,
+  listCoworkWorkspaceDirCandidates,
   parseEnvFile,
+  detectCoworkWorkspaceDir,
   autoDetectBaseUrl,
   PROD_URL,
 };

package/dist/bundling-sources/sdk/src/release.ts

@@ -101,10 +101,10 @@ export const SDK_RELEASE = {
   // 0.1.108 ships explicit dataset column/tool recompute policy and removes
   // the SDK enrich generator's one-second stale policy.
   // 0.1.110 ships authored V2 prebuilts and required top-level play descriptions.
-  version: '0.1.143',
+  version: '0.1.144',
   apiContract: '2026-06-dataset-column-cell-stale-hard-cutover',
   supportPolicy: {
-    latest: '0.1.143',
+    latest: '0.1.144',
     minimumSupported: '0.1.53',
     deprecatedBelow: '0.1.53',
     commandMinimumSupported: [