deepline 0.1.12 → 0.1.20

package/dist/index.mjs

@@ -42,6 +42,10 @@ var ConfigError = class extends DeeplineError {
 var PROD_URL = "https://code.deepline.com";
 var DEFAULT_TIMEOUT = 6e4;
 var DEFAULT_MAX_RETRIES = 3;
+var ACTIVE_DEEPLINE_ENV_FILE = ".env.deepline";
+function projectEnvStartDir() {
+  return process.env.DEEPLINE_PROJECT_ENV_DIR?.trim() || process.cwd();
+}
 function baseUrlSlug(baseUrl) {
   let url;
   try {
@@ -77,16 +81,52 @@ function parseEnvFile(filePath) {
   }
   return env;
 }
-function findNearestWorktreeEnv(startDir = process.cwd()) {
+function findNearestEnvFile(names, startDir = process.cwd()) {
   let current = resolve(startDir);
   while (true) {
-    const values = parseEnvFile(join(current, ".env.worktree"));
-    if (Object.keys(values).length > 0) return values;
+    for (const name of names) {
+      const filePath = join(current, name);
+      if (existsSync(filePath)) return filePath;
+    }
     const parent = dirname(current);
-    if (parent === current) return {};
+    if (parent === current) return null;
     current = parent;
   }
 }
+function findNearestEnv(names, startDir = process.cwd()) {
+  const filePath = findNearestEnvFile(names, startDir);
+  return filePath ? parseEnvFile(filePath) : {};
+}
+function findNearestWorktreeEnv(startDir = process.cwd()) {
+  return findNearestEnv([".env.worktree"], startDir);
+}
+function resolveProfileEnvFileNames() {
+  const explicitProfile = process.env.DEEPLINE_ENV_PROFILE?.trim() || process.env.DEEPLINE_PROFILE?.trim() || "";
+  const names = [];
+  if (explicitProfile) names.push(`.env.deepline.${explicitProfile}`);
+  const nodeEnv = process.env.NODE_ENV?.trim();
+  if (nodeEnv === "production") names.push(".env.deepline.prod");
+  else if (nodeEnv === "staging") names.push(".env.deepline.staging");
+  names.push(ACTIVE_DEEPLINE_ENV_FILE);
+  return names;
+}
+function resolveProjectAppEnvFileNames() {
+  const nodeEnv = process.env.NODE_ENV?.trim();
+  const names = [];
+  if (nodeEnv === "production") names.push(".env.prod");
+  if (nodeEnv === "staging") names.push(".env.staging");
+  names.push(".env.local", ".env");
+  return names;
+}
+function resolveBaseUrlFromEnvValues(env) {
+  return env.DEEPLINE_ORIGIN_URL?.trim() || env.DEEPLINE_API_BASE_URL?.trim() || "";
+}
+function loadProjectDeeplineEnv() {
+  return findNearestEnv(resolveProfileEnvFileNames(), projectEnvStartDir());
+}
+function loadProjectAppEnv() {
+  return findNearestEnv(resolveProjectAppEnvFileNames(), projectEnvStartDir());
+}
 function normalizeWorktreeBaseUrl(baseUrl, worktreeEnv = findNearestWorktreeEnv()) {
   const trimmed = baseUrl.trim().replace(/\/$/, "");
   if (!trimmed) return trimmed;
@@ -123,6 +163,10 @@ function autoDetectBaseUrl() {
   if (envOrigin) return normalizeWorktreeBaseUrl(envOrigin);
   const envBase = process.env.DEEPLINE_API_BASE_URL?.trim();
   if (envBase) return normalizeWorktreeBaseUrl(envBase);
+  const projectDeeplineBaseUrl = resolveBaseUrlFromEnvValues(loadProjectDeeplineEnv());
+  if (projectDeeplineBaseUrl) return normalizeWorktreeBaseUrl(projectDeeplineBaseUrl);
+  const projectAppBaseUrl = resolveBaseUrlFromEnvValues(loadProjectAppEnv());
+  if (projectAppBaseUrl) return normalizeWorktreeBaseUrl(projectAppBaseUrl);
   const worktreeBaseUrl = resolveWorktreeBaseUrl();
   if (worktreeBaseUrl) return worktreeBaseUrl;
   const globalEnv = loadGlobalCliEnv();
@@ -134,7 +178,9 @@ function resolveConfig(options) {
   const requestedBaseUrl = options?.baseUrl?.trim() || autoDetectBaseUrl();
   const baseUrl = normalizeWorktreeBaseUrl(requestedBaseUrl);
   const cliEnv = loadCliEnv(baseUrl);
-  const apiKey = options?.apiKey?.trim() || process.env.DEEPLINE_API_KEY?.trim() || cliEnv.DEEPLINE_API_KEY || "";
+  const projectDeeplineEnv = loadProjectDeeplineEnv();
+  const projectAppEnv = loadProjectAppEnv();
+  const apiKey = options?.apiKey?.trim() || process.env.DEEPLINE_API_KEY?.trim() || projectDeeplineEnv.DEEPLINE_API_KEY || projectAppEnv.DEEPLINE_API_KEY || cliEnv.DEEPLINE_API_KEY || "";
   if (!apiKey) {
     throw new ConfigError(
       `No API key found. Set DEEPLINE_API_KEY env var, pass apiKey option, or run: deepline auth register`
@@ -149,8 +195,8 @@ function resolveConfig(options) {
 }
 
 // src/version.ts
-var SDK_VERSION = "0.1.12";
-var SDK_API_CONTRACT = "2026-04-plays-v1";
+var SDK_VERSION = "0.1.20";
+var SDK_API_CONTRACT = "2026-05-runs-v2";
 
 // ../shared_libs/play-runtime/coordinator-headers.ts
 var COORDINATOR_INTERNAL_TOKEN_HEADER = "x-deepline-internal-token";
@@ -256,7 +302,8 @@ var HttpClient = class {
             parsed = body;
           }
           if (!response.ok) {
-            const msg = typeof parsed === "object" && parsed && "error" in parsed ? String(parsed.error) : `HTTP ${response.status}`;
+            const errorValue = typeof parsed === "object" && parsed && "error" in parsed ? parsed.error : void 0;
+            const msg = typeof errorValue === "string" ? errorValue : errorValue && typeof errorValue === "object" && "message" in errorValue && typeof errorValue.message === "string" ? errorValue.message : typeof parsed === "object" && parsed && "message" in parsed && typeof parsed.message === "string" ? parsed.message : `HTTP ${response.status}`;
             throw new DeeplineError(msg, response.status, "API_ERROR", {
               response: parsed
             });
@@ -343,8 +390,12 @@ var HttpClient = class {
    * @param path - API path
    * @param body - Request body (will be JSON-serialized)
    */
-  async post(path, body) {
-    return this.request(path, { method: "POST", body });
+  async post(path, body, headers) {
+    return this.request(path, {
+      method: "POST",
+      body,
+      headers
+    });
   }
   /**
    * Send a DELETE request.
@@ -424,6 +475,7 @@ function sleep(ms) {
 
 // src/client.ts
 var TERMINAL_PLAY_STATUSES = /* @__PURE__ */ new Set(["completed", "failed", "cancelled"]);
+var INCLUDE_TOOL_METADATA_HEADER = "x-deepline-include-tool-metadata";
 function isRecord(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
@@ -456,6 +508,7 @@ function mapLegacyTemporalStatus(status) {
 var DeeplineClient = class {
   http;
   config;
+  runs;
   /**
    * @param options - Optional overrides for API key, base URL, timeout, and retries.
    * @throws {@link ConfigError} if no API key can be resolved from any source.
@@ -463,6 +516,13 @@ var DeeplineClient = class {
   constructor(options) {
     this.config = resolveConfig(options);
     this.http = new HttpClient(this.config);
+    this.runs = {
+      get: (runId) => this.getRunStatus(runId),
+      list: (options2) => this.listRuns(options2),
+      tail: (runId, options2) => this.tailRun(runId, options2),
+      logs: (runId, options2) => this.getRunLogs(runId, options2),
+      stop: (runId, options2) => this.stopRun(runId, options2)
+    };
   }
   /** The resolved base URL this client is targeting (e.g. `"http://localhost:3000"`). */
   get baseUrl() {
@@ -551,6 +611,31 @@ var DeeplineClient = class {
     );
     return res.tools;
   }
+  /**
+   * Search available tools using Deepline's ranked backend search.
+   *
+   * This is the same discovery surface used by the legacy CLI: it ranks across
+   * tool metadata, categories, agent guidance, and input schema fields.
+   */
+  async searchTools(options = {}) {
+    const params = new URLSearchParams();
+    const query = options.query?.trim() ?? "";
+    params.set("q", query);
+    params.set(
+      "include_search_debug",
+      options.includeSearchDebug ? "true" : "false"
+    );
+    params.set("search_mode", options.searchMode ?? "v2");
+    if (options.categories?.trim()) {
+      params.set("categories", options.categories.trim());
+    }
+    if (options.searchTerms?.trim()) {
+      params.set("search_terms", options.searchTerms.trim());
+    }
+    return this.http.get(
+      `/api/v2/integrations/list?${params.toString()}`
+    );
+  }
   /**
    * Get detailed metadata for a single tool.
    *
@@ -586,12 +671,17 @@ var DeeplineClient = class {
    * Top-level fields such as `status`, `job_id`, and `billing` describe the
    * Deepline execution.
    */
-  async executeTool(toolId, input) {
+  async executeTool(toolId, input, options) {
+    const headers = options?.includeToolMetadata ? { [INCLUDE_TOOL_METADATA_HEADER]: "true" } : void 0;
     return this.http.post(
       `/api/v2/integrations/${encodeURIComponent(toolId)}/execute`,
-      { payload: input }
+      { payload: input },
+      headers
     );
   }
+  async executeToolRaw(toolId, input, options) {
+    return this.executeTool(toolId, input, options);
+  }
   async queryCustomerDb(input) {
     return this.http.post("/api/v2/db/query", {
       sql: input.sql,
@@ -640,6 +730,7 @@ var DeeplineClient = class {
       ...request.revisionId ? { revisionId: request.revisionId } : {},
       ...request.artifactStorageKey ? { artifactStorageKey: request.artifactStorageKey } : {},
       ...request.sourceCode ? { sourceCode: request.sourceCode } : {},
+      ...request.sourceFiles ? { sourceFiles: request.sourceFiles } : {},
       ..."staticPipeline" in request ? { staticPipeline: request.staticPipeline } : {},
       ...request.artifactHash ? { artifactHash: request.artifactHash } : {},
       ...request.graphHash ? { graphHash: request.graphHash } : {},
@@ -664,6 +755,7 @@ var DeeplineClient = class {
       ...request.revisionId ? { revisionId: request.revisionId } : {},
       ...request.artifactStorageKey ? { artifactStorageKey: request.artifactStorageKey } : {},
       ...request.sourceCode ? { sourceCode: request.sourceCode } : {},
+      ...request.sourceFiles ? { sourceFiles: request.sourceFiles } : {},
       ..."staticPipeline" in request ? { staticPipeline: request.staticPipeline } : {},
       ...request.artifactHash ? { artifactHash: request.artifactHash } : {},
       ...request.graphHash ? { graphHash: request.graphHash } : {},
@@ -700,6 +792,7 @@ var DeeplineClient = class {
     const compilerManifest = input.compilerManifest ?? await this.compilePlayManifest({
       name: input.name,
       sourceCode: input.sourceCode,
+      sourceFiles: input.sourceFiles,
       artifact: input.artifact
     });
     return this.http.post("/api/v2/plays/artifacts", {
@@ -714,6 +807,7 @@ var DeeplineClient = class {
         compilerManifest: artifact.compilerManifest ?? await this.compilePlayManifest({
           name: artifact.name,
           sourceCode: artifact.sourceCode,
+          sourceFiles: artifact.sourceFiles,
           artifact: artifact.artifact
         })
       }))
@@ -740,11 +834,13 @@ var DeeplineClient = class {
     const compilerManifest = input.compilerManifest ?? await this.compilePlayManifest({
       name: input.name,
       sourceCode: input.sourceCode,
+      sourceFiles: input.sourceFiles,
       artifact: input.artifact
     });
     const registeredArtifact = await this.registerPlayArtifact({
       name: input.name,
       sourceCode: input.sourceCode,
+      sourceFiles: input.sourceFiles,
       artifact: input.artifact,
       compilerManifest,
       publish: false
@@ -804,11 +900,13 @@ var DeeplineClient = class {
     const compilerManifest = options?.compilerManifest ?? await this.compilePlayManifest({
       name,
       sourceCode,
+      sourceFiles: options?.sourceFiles,
       artifact
     });
     const registeredArtifact = await this.registerPlayArtifact({
       name,
       sourceCode,
+      sourceFiles: options?.sourceFiles,
       artifact,
       compilerManifest,
       publish: false
@@ -992,6 +1090,112 @@ var DeeplineClient = class {
     );
     return response.runs ?? [];
   }
+  /**
+   * Get a run by id using the public runs resource model.
+   *
+   * This is the SDK equivalent of:
+   *
+   * ```bash
+   * deepline runs get <run-id> --json
+   * ```
+   */
+  async getRunStatus(runId) {
+    const response = await this.http.get(
+      `/api/v2/runs/${encodeURIComponent(runId)}`
+    );
+    return normalizePlayStatus(response);
+  }
+  /**
+   * List play runs using the public runs resource model.
+   *
+   * This is the SDK equivalent of:
+   *
+   * ```bash
+   * deepline runs list --play <play-name> --status failed --json
+   * ```
+   */
+  async listRuns(options) {
+    const playName = options.play.trim();
+    if (!playName) {
+      throw new Error("runs.list requires options.play.");
+    }
+    const params = new URLSearchParams({ play: playName });
+    const status = options.status?.trim();
+    if (status) {
+      params.set("status", status);
+    }
+    const response = await this.http.get(
+      `/api/v2/runs?${params.toString()}`
+    );
+    return response.runs ?? [];
+  }
+  /**
+   * Fetch the lightweight tail status for a run using the public runs resource model.
+   *
+   * This is the SDK equivalent of:
+   *
+   * ```bash
+   * deepline runs tail <run-id> --json
+   * ```
+   */
+  async tailRun(runId, options) {
+    const afterLogIndex = typeof options?.afterLogIndex === "number" ? options.afterLogIndex : typeof options?.cursor === "number" ? options.cursor : typeof options?.cursor === "string" && options.cursor.trim() ? Number(options.cursor) : void 0;
+    const params = new URLSearchParams();
+    if (Number.isFinite(afterLogIndex)) {
+      params.set("afterLogIndex", String(Number(afterLogIndex)));
+    }
+    if (typeof options?.waitMs === "number") {
+      params.set("waitMs", String(options.waitMs));
+    }
+    if (options?.terminalOnly) {
+      params.set("terminalOnly", "true");
+    }
+    const suffix = params.toString() ? `?${params.toString()}` : "";
+    const response = await this.http.get(
+      `/api/v2/runs/${encodeURIComponent(runId)}/tail${suffix}`
+    );
+    return normalizePlayStatus(response);
+  }
+  /**
+   * Fetch persisted logs for a run using the public runs resource model.
+   *
+   * This is the SDK equivalent of:
+   *
+   * ```bash
+   * deepline runs logs <run-id> --limit 200 --json
+   * ```
+   */
+  async getRunLogs(runId, options) {
+    const status = await this.getRunStatus(runId);
+    const logs = status.progress?.logs ?? [];
+    const limit = typeof options?.limit === "number" && Number.isFinite(options.limit) ? Math.max(0, Math.trunc(options.limit)) : 200;
+    const entries = logs.slice(Math.max(0, logs.length - limit));
+    return {
+      runId: status.runId,
+      totalCount: logs.length,
+      returnedCount: entries.length,
+      firstSequence: logs.length === 0 ? null : logs.length - entries.length + 1,
+      lastSequence: logs.length === 0 ? null : logs.length,
+      truncated: logs.length > entries.length,
+      hasMore: logs.length > entries.length,
+      entries
+    };
+  }
+  /**
+   * Stop a run by id using the public runs resource model.
+   *
+   * This is the SDK equivalent of:
+   *
+   * ```bash
+   * deepline runs stop <run-id> --reason "stale lock" --json
+   * ```
+   */
+  async stopRun(runId, options) {
+    return this.http.post(
+      `/api/v2/runs/${encodeURIComponent(runId)}/stop`,
+      options?.reason ? { reason: options.reason } : {}
+    );
+  }
   async listPlays() {
     const response = await this.http.get(
       "/api/v2/plays"
@@ -1357,7 +1561,11 @@ var DeeplineContext = class {
       /** Get detailed metadata for a tool. */
       get: (toolId) => this.client.getTool(toolId),
       /** Execute a tool and return the standard execution envelope. */
-      execute: async (toolId, input) => this.client.executeTool(toolId, input)
+      execute: async (toolId, input) => this.client.executeTool(
+        toolId,
+        input,
+        { includeToolMetadata: true }
+      )
     };
   }
   get plays() {
@@ -1724,4 +1932,3 @@ export {
   writeCsvOutputFile,
   writeJsonOutputFile
 };
-//# sourceMappingURL=index.mjs.map