deepline 0.1.66 → 0.1.67

package/dist/cli/index.js

@@ -229,10 +229,10 @@ var import_node_path2 = require("path");
 
 // src/release.ts
 var SDK_RELEASE = {
-  version: "0.1.66",
+  version: "0.1.67",
   apiContract: "2026-05-play-bootstrap-dataset-summary",
   supportPolicy: {
-    latest: "0.1.66",
+    latest: "0.1.67",
     minimumSupported: "0.1.53",
     deprecatedBelow: "0.1.53"
   }
@@ -483,6 +483,9 @@ var HttpClient = class {
       headers
     });
   }
+  async patch(path, body, headers) {
+    return this.request(path, { method: "PATCH", body, headers });
+  }
   /**
    * Send a DELETE request.
    *
@@ -1606,6 +1609,61 @@ var DeeplineClient = class {
     return this.http.delete(`/api/v2/plays/${encodedName}`);
   }
   // ——————————————————————————————————————————————————————————
+  // Plays — public share pages
+  // ——————————————————————————————————————————————————————————
+  /**
+   * Current share status for a play: the public page (if any), the published
+   * copy, and the revision picker. Read-only.
+   */
+  async getSharePage(name) {
+    const encodedName = encodeURIComponent(name);
+    return this.http.get(`/api/v2/plays/${encodedName}/share`);
+  }
+  /**
+   * Publish (or repoint) the play's public share page to a revision. Requires
+   * `acknowledgedUnlisted: true` — the page is publicly viewable. Org-admin only.
+   */
+  async publishSharePage(name, request) {
+    const encodedName = encodeURIComponent(name);
+    return this.http.post(
+      `/api/v2/plays/${encodedName}/share`,
+      request
+    );
+  }
+  /**
+   * Update share-page settings (SEO indexing, credit-cost / latency display)
+   * without moving the published pointer. Org-admin only.
+   */
+  async updateSharePage(name, request) {
+    const encodedName = encodeURIComponent(name);
+    return this.http.patch(
+      `/api/v2/plays/${encodedName}/share`,
+      request
+    );
+  }
+  /**
+   * Unshare: hard-delete the play's public page and its cards. Returns the
+   * fresh status (now `share: null`). Org-admin only. Idempotent — a no-op when
+   * the play was never published.
+   */
+  async unpublishSharePage(name) {
+    const encodedName = encodeURIComponent(name);
+    return this.http.delete(
+      `/api/v2/plays/${encodedName}/share`
+    );
+  }
+  /**
+   * Regenerate the LLM landing-page copy for a revision (defaults to the
+   * published one). Org-admin only.
+   */
+  async regenerateSharePage(name, request = {}) {
+    const encodedName = encodeURIComponent(name);
+    return this.http.post(
+      `/api/v2/plays/${encodedName}/share/regenerate`,
+      request
+    );
+  }
+  // ——————————————————————————————————————————————————————————
   // Plays — high-level orchestration
   // ——————————————————————————————————————————————————————————
   /**
@@ -12096,6 +12154,331 @@ Examples:
       ...options.json ? ["--json"] : []
     ]);
   });
+  const share = play.command("share").description(
+    "Manage a play's public, unlisted share page (advanced \u2014 exposes play code)."
+  ).addHelpText(
+    "after",
+    `
+Concepts:
+  A share page is a public, unlisted, SEO-indexable landing page for a play,
+  pinned to one revision. Publish only after the play has run successfully.
+
+  NOT RECOMMENDED by default. Only publish when the user has explicitly asked
+  to share this play AND has confirmed they accept the risks below. When in
+  doubt, leave the play unpublished.
+
+What is exposed:
+  Run results and row-level data are NEVER exposed. But the page renders the
+  play's STRUCTURE and anything baked into its source code: step names,
+  input/output field names, tool ids, step descriptions/prompts, and any
+  hardcoded string literals or comments in the play file. If the source
+  contains PII, internal domains/emails, secrets-by-mistake, or proprietary
+  business logic, publishing makes it publicly viewable and search-indexable.
+
+  Review the play source for sensitive content before publishing. Use
+  --seo noindex to keep the page out of search engines if you must share it.
+
+Examples:
+  deepline plays share status company-to-contact --json
+  deepline plays share publish company-to-contact --yes
+  deepline plays share publish company-to-contact --version 3 --seo noindex --yes
+  deepline plays share update company-to-contact --show-latency --json
+  deepline plays share regenerate company-to-contact --json
+  deepline plays share unpublish company-to-contact --yes
+`
+  );
+  share.command("status <play>").description("Show a play's share-page status and revision picker.").option("--json", "Emit JSON output. Also automatic when stdout is piped").action(async (playName, options) => {
+    process.exitCode = await handlePlayShareStatus([
+      playName,
+      ...options.json ? ["--json"] : []
+    ]);
+  });
+  share.command("publish <play>").description(
+    "Publish/repoint a PUBLIC page to a revision. Advanced; not recommended unless explicitly requested and risks confirmed."
+  ).option("--latest", "Publish the newest revision (default).").option("--version <n>", "Publish a specific version number.").option("--revision-id <id>", "Publish a specific revision id.").option("--seo <mode>", "SEO indexing: index | noindex.").option("--show-cost", "Show average Deepline credit cost on the page.").option("--show-latency", "Show average latency on the page.").option("--no-run-check", 'Skip the "must have a completed run" gate.').option(
+    "-y, --yes",
+    "Confirm public exposure of the play code/structure (required)."
+  ).option("--dry-run", "Show the planned publish without writing.").option("--json", "Emit JSON output. Also automatic when stdout is piped").addHelpText(
+    "after",
+    `
+WARNING \u2014 not recommended by default.
+  Only run when the user has explicitly asked to share this play AND has
+  confirmed they accept the exposure risks. Otherwise, do not publish.
+
+  Mutates cloud state. Creates a PUBLIC, SEO-indexable (unless --seo noindex),
+  unlisted page; requires --yes to acknowledge it is publicly viewable.
+
+  Run results and row data are NEVER exposed. The page DOES expose the play's
+  code/structure: step names, input/output field names, tool ids, step
+  descriptions/prompts, and any hardcoded literals or comments in the source.
+  This may reveal PII, internal domains/emails, or proprietary logic if such
+  content lives in the play file. Review the source before publishing.
+
+Exit codes: 0 ok; 2 usage/missing --yes; 4 play or version not found;
+  7 no successful run for the play.
+
+Examples:
+  deepline plays share publish company-to-contact --yes
+  deepline plays share publish company-to-contact --version 3 --seo noindex --yes --json
+`
+  ).action(async (playName, options) => {
+    process.exitCode = await handlePlaySharePublish([
+      playName,
+      ...options.latest ? ["--latest"] : [],
+      ...options.version ? ["--version", String(options.version)] : [],
+      ...options.revisionId ? ["--revision-id", options.revisionId] : [],
+      ...options.seo ? ["--seo", options.seo] : [],
+      ...options.showCost ? ["--show-cost"] : [],
+      ...options.showLatency ? ["--show-latency"] : [],
+      ...options.runCheck === false ? ["--no-run-check"] : [],
+      ...options.yes ? ["--yes"] : [],
+      ...options.dryRun ? ["--dry-run"] : [],
+      ...options.json ? ["--json"] : []
+    ]);
+  });
+  share.command("update <play>").description("Update share-page settings without moving the pointer.").option("--seo <mode>", "SEO indexing: index | noindex.").option("--show-cost", "Show average Deepline credit cost.").option("--hide-cost", "Hide average Deepline credit cost.").option("--show-latency", "Show average latency.").option("--hide-latency", "Hide average latency.").option("--json", "Emit JSON output. Also automatic when stdout is piped").action(async (playName, options) => {
+    process.exitCode = await handlePlayShareUpdate([
+      playName,
+      ...options.seo ? ["--seo", options.seo] : [],
+      ...options.showCost ? ["--show-cost"] : [],
+      ...options.hideCost ? ["--hide-cost"] : [],
+      ...options.showLatency ? ["--show-latency"] : [],
+      ...options.hideLatency ? ["--hide-latency"] : [],
+      ...options.json ? ["--json"] : []
+    ]);
+  });
+  share.command("regenerate <play>").description("Regenerate the public page's LLM copy for a revision.").option("--version <n>", "Regenerate a specific version number.").option("--revision-id <id>", "Regenerate a specific revision id.").option("--json", "Emit JSON output. Also automatic when stdout is piped").action(async (playName, options) => {
+    process.exitCode = await handlePlayShareRegenerate([
+      playName,
+      ...options.version ? ["--version", String(options.version)] : [],
+      ...options.revisionId ? ["--revision-id", options.revisionId] : [],
+      ...options.json ? ["--json"] : []
+    ]);
+  });
+  share.command("unpublish <play>").description(
+    "Unshare: permanently delete the public page (frees it). Requires --yes."
+  ).option("-y, --yes", "Confirm taking the public page down (required).").option("--json", "Emit JSON output. Also automatic when stdout is piped").addHelpText(
+    "after",
+    `
+Mutates cloud state. Hard-deletes the page + its generated cards; the URL stops
+resolving. Org-admin only. Exit codes: 0 ok; 2 usage/missing --yes; 4 play not
+found.
+
+Examples:
+  deepline plays share unpublish company-to-contact --yes
+`
+  ).action(async (playName, options) => {
+    process.exitCode = await handlePlayShareUnpublish([
+      playName,
+      ...options.yes ? ["--yes"] : [],
+      ...options.json ? ["--json"] : []
+    ]);
+  });
+}
+function shareFlagValue(args, flag) {
+  const i = args.indexOf(flag);
+  return i >= 0 && i + 1 < args.length ? args[i + 1] : void 0;
+}
+async function handlePlayShareStatus(args) {
+  const target = args[0];
+  if (!target) {
+    console.error("Usage: deepline plays share status <play> [--json]");
+    return 2;
+  }
+  const name = parseReferencedPlayTarget2(target).playName;
+  const status = await new DeeplineClient().getSharePage(name);
+  if (argsWantJson(args)) {
+    process.stdout.write(`${JSON.stringify(status)}
+`);
+    return 0;
+  }
+  if (!status.share) {
+    console.log(`${status.playName}: not published.`);
+    console.log(
+      `  Publish: deepline plays share publish ${status.playName} --yes`
+    );
+    return 0;
+  }
+  console.log(`${status.playName}: published v${status.share.publishedVersion}`);
+  console.log(`  url:  ${status.share.publicPath}`);
+  console.log(`  seo:  ${status.share.seoIndexing}`);
+  console.log(
+    `  show: cost=${status.share.showAverageDeeplineCost} latency=${status.share.showAverageLatency}`
+  );
+  return 0;
+}
+async function handlePlaySharePublish(args) {
+  const target = args[0];
+  if (!target) {
+    console.error(
+      "Usage: deepline plays share publish <play> (--latest | --version <n> | --revision-id <id>) --yes [--seo index|noindex] [--show-cost] [--show-latency] [--json]"
+    );
+    return 2;
+  }
+  if (!args.includes("--yes")) {
+    console.error(
+      "Publishing creates a PUBLIC, SEO-indexable page. NOT recommended unless\nyou explicitly intend to share this play and accept the risks.\nRun results stay private, but the page exposes the play CODE: step names,\nfield names, tool ids, prompts/descriptions, and any hardcoded literals or\ncomments in the source \u2014 which may reveal PII or proprietary logic.\nReview the play source, then re-run with --yes to confirm."
+    );
+    return 2;
+  }
+  const name = parseReferencedPlayTarget2(target).playName;
+  const client = new DeeplineClient();
+  let revisionId = shareFlagValue(args, "--revision-id");
+  let resolvedVersion;
+  if (!revisionId) {
+    const versions = await client.listPlayVersions(name);
+    if (versions.length === 0) {
+      console.error(
+        `No saved revisions for ${name}. Run \`deepline plays set-live ${name}\` first.`
+      );
+      return 4;
+    }
+    const versionFlag = shareFlagValue(args, "--version");
+    const chosen = versionFlag ? versions.find((r) => r.version === Number(versionFlag)) : versions[0];
+    if (!chosen) {
+      console.error(`Version ${versionFlag} not found for ${name}.`);
+      return 4;
+    }
+    if (!chosen._id) {
+      console.error("Resolved revision is missing an id.");
+      return 5;
+    }
+    revisionId = chosen._id;
+    resolvedVersion = chosen.version;
+  }
+  if (!args.includes("--no-run-check")) {
+    const runs = await client.listRuns({ play: name });
+    const hasCompleted = runs.some(
+      (r) => String(r.status).toLowerCase() === "completed"
+    );
+    if (!hasCompleted) {
+      const message = `No completed run for ${name}. Publish a play only after it has run successfully. (Override with --no-run-check.)`;
+      if (argsWantJson(args)) {
+        process.stdout.write(
+          `${JSON.stringify({ ok: false, code: "NO_SUCCESSFUL_RUN", message, next: `deepline plays run ${name} --wait` })}
+`
+        );
+      } else {
+        console.error(message);
+        console.error(`  deepline plays run ${name} --wait`);
+      }
+      return 7;
+    }
+  }
+  const seo = shareFlagValue(args, "--seo");
+  const seoIndexing = seo === "index" ? "index" : seo === "noindex" ? "noindex" : void 0;
+  const request = {
+    revisionId,
+    acknowledgedUnlisted: true,
+    showAverageDeeplineCost: args.includes("--show-cost"),
+    showAverageLatency: args.includes("--show-latency"),
+    ...seoIndexing ? { seoIndexing } : {}
+  };
+  if (args.includes("--dry-run")) {
+    const plan = { dryRun: true, name, version: resolvedVersion, ...request };
+    if (argsWantJson(args)) {
+      process.stdout.write(`${JSON.stringify(plan)}
+`);
+    } else {
+      console.log(
+        `Would publish ${name}${resolvedVersion ? ` v${resolvedVersion}` : ""} (revision ${revisionId}).`
+      );
+    }
+    return 0;
+  }
+  const status = await client.publishSharePage(name, request);
+  if (argsWantJson(args)) {
+    process.stdout.write(`${JSON.stringify(status)}
+`);
+    return 0;
+  }
+  console.log(
+    `Published ${name}${status.share ? ` v${status.share.publishedVersion}` : ""}: ${status.share?.publicPath ?? ""}`
+  );
+  if (status.warning) {
+    console.error(`warning: ${status.warning}`);
+  }
+  return 0;
+}
+async function handlePlayShareUpdate(args) {
+  const target = args[0];
+  if (!target) {
+    console.error(
+      "Usage: deepline plays share update <play> [--seo index|noindex] [--show-cost|--hide-cost] [--show-latency|--hide-latency] [--json]"
+    );
+    return 2;
+  }
+  const name = parseReferencedPlayTarget2(target).playName;
+  const seo = shareFlagValue(args, "--seo");
+  const seoIndexing = seo === "index" ? "index" : seo === "noindex" ? "noindex" : void 0;
+  const request = {
+    ...args.includes("--show-cost") ? { showAverageDeeplineCost: true } : args.includes("--hide-cost") ? { showAverageDeeplineCost: false } : {},
+    ...args.includes("--show-latency") ? { showAverageLatency: true } : args.includes("--hide-latency") ? { showAverageLatency: false } : {},
+    ...seoIndexing ? { seoIndexing } : {}
+  };
+  const status = await new DeeplineClient().updateSharePage(name, request);
+  if (argsWantJson(args)) {
+    process.stdout.write(`${JSON.stringify(status)}
+`);
+    return 0;
+  }
+  console.log(`Updated ${name} share settings.`);
+  return 0;
+}
+async function handlePlayShareRegenerate(args) {
+  const target = args[0];
+  if (!target) {
+    console.error(
+      "Usage: deepline plays share regenerate <play> [--version <n> | --revision-id <id>] [--json]"
+    );
+    return 2;
+  }
+  const name = parseReferencedPlayTarget2(target).playName;
+  const client = new DeeplineClient();
+  let revisionId = shareFlagValue(args, "--revision-id");
+  const versionFlag = shareFlagValue(args, "--version");
+  if (!revisionId && versionFlag) {
+    const versions = await client.listPlayVersions(name);
+    const chosen = versions.find((r) => r.version === Number(versionFlag));
+    if (!chosen?._id) {
+      console.error(`Version ${versionFlag} not found for ${name}.`);
+      return 4;
+    }
+    revisionId = chosen._id;
+  }
+  const status = await client.regenerateSharePage(
+    name,
+    revisionId ? { revisionId } : {}
+  );
+  if (argsWantJson(args)) {
+    process.stdout.write(`${JSON.stringify(status)}
+`);
+    return 0;
+  }
+  console.log(`Regenerated public copy for ${name}.`);
+  return 0;
+}
+async function handlePlayShareUnpublish(args) {
+  const target = args[0];
+  if (!target) {
+    console.error("Usage: deepline plays share unpublish <play> --yes [--json]");
+    return 2;
+  }
+  if (!args.includes("--yes")) {
+    console.error(
+      "Unpublishing permanently deletes the public page and frees its URL.\nRe-run with --yes to confirm."
+    );
+    return 2;
+  }
+  const name = parseReferencedPlayTarget2(target).playName;
+  const status = await new DeeplineClient().unpublishSharePage(name);
+  if (argsWantJson(args)) {
+    process.stdout.write(`${JSON.stringify(status)}
+`);
+    return 0;
+  }
+  console.log(`Unpublished ${name}; the public page has been removed.`);
+  return 0;
 }
 
 // src/cli/commands/tools.ts