syndai 0.5.0 → 0.7.0

package/src/portal.js

@@ -0,0 +1,156 @@
+// What stays in the browser, one step away: `connect` and `billing` hand off to the exact
+// workspace page (G1: `portalUrl`). Connections and payment need a person there, so no key
+// may read connection status or pay; the CLI prints the page, opens it on a terminal and
+// never polls. `billing` reads the balance and starts a checkout a person then pays.
+
+import { CliError, EXIT, UnavailableError, portalUrl } from "./errors.js";
+import { openPage } from "./ui.js";
+
+/** `syndai connect <provider>` -> its card. The `connect` list is the portal's
+ * `CONNECT_PROVIDERS` (apps/portal-v2/src/lib/connection-link.ts). */
+const CONNECTIONS = [
+  "claude",
+  "chatgpt",
+  "openrouter",
+  "linkedin",
+  "instagram",
+  "x",
+  "threads",
+  "bluesky",
+  "buffer",
+  "tiktok",
+  "youtube",
+  "slack",
+];
+export const CONNECT_PAGES = Object.freeze({
+  github: "settings#repositories",
+  sentry: "sentry",
+  ...Object.fromEntries(CONNECTIONS.map((provider) => [provider, `connections?connect=${provider}`])),
+});
+
+/** Print a workspace page (JSON: `{url}`), say what to do there, open it on a terminal. */
+function handOff(ctx, url, line, data = {}) {
+  ctx.ui.result({ ...data, url }, url);
+  if (!ctx.ui.json) ctx.ui.progress(line);
+  openPage(ctx, url);
+  return EXIT.OK;
+}
+
+export async function connect(ctx, [provider]) {
+  const names = Object.keys(CONNECT_PAGES).join(", ");
+  const page = provider ? CONNECT_PAGES[provider.toLowerCase()] : null;
+  if (!page) {
+    throw new CliError(EXIT.USAGE, provider ? `Unknown provider "${provider}". One of: ${names}.` : `Connect what? One of: ${names}.`);
+  }
+  return handOff(ctx, portalUrl(await ctx.customerId(), page), "Finish in the browser.");
+}
+
+export async function billing(ctx, [sub = "status", arg]) {
+  switch (sub) {
+    case "status":
+      return billingStatus(ctx);
+    case "packs":
+      return packs(ctx);
+    case "buy":
+      return buy(ctx, arg);
+    case "plan":
+      return plan(ctx, arg);
+    case "card":
+    case "cancel":
+      return handOff(
+        ctx,
+        portalUrl(await ctx.customerId(), "billing"),
+        "Change the card, plan or cancel on this page.",
+      );
+    default:
+      throw new CliError(EXIT.USAGE, `Unknown billing command "${sub}". Use packs, buy, plan, card or cancel.`);
+  }
+}
+
+const dollars = (usd) => `${usd < 0 ? "-" : ""}$${Math.abs(usd).toFixed(2)}`;
+
+async function billingStatus(ctx) {
+  const { client, ui, io, flags } = ctx;
+  const [usage, subscription, customerId] = await Promise.all([
+    client.call("usage"),
+    // The plan's renewal comes from the payment provider: its outage only drops that line.
+    client.call("subscription").then(
+      (body) => body?.subscription ?? null,
+      (err) => {
+        if (err instanceof UnavailableError) return null;
+        throw err;
+      },
+    ),
+    ctx.customerId(),
+  ]);
+  // The portal's `balanceUsd` (apps/portal-v2/src/sync/usage-api.ts): packs + included left - holds.
+  const held = usage.bids_usd ?? 0;
+  const balance = usage.pack_balance_usd + usage.included_remaining_usd - held;
+  const url = portalUrl(customerId, "billing");
+  const planCode = subscription?.plan_code ?? usage.plan_code ?? null;
+  const renews = subscription?.current_period_end
+    ? ` (${subscription.interval ?? ""}ly, ${subscription.cancel_at_period_end ? "ends" : "renews"} ${subscription.current_period_end.slice(0, 10)})`
+    : "";
+  const parts = [`packs ${dollars(usage.pack_balance_usd)}`, `included ${dollars(usage.included_remaining_usd)} left`];
+  if (held) parts.push(`${dollars(held)} held`);
+  ui.result(
+    {
+      plan_code: planCode,
+      subscription,
+      balance_usd: balance,
+      pack_balance_usd: usage.pack_balance_usd,
+      included_remaining_usd: usage.included_remaining_usd,
+      bids_usd: held,
+      included_resets_at: usage.included_resets_at ?? null,
+      url,
+    },
+    [`Plan     ${planCode ?? "unknown"}${renews}`, `Balance  ${dollars(balance)} (${parts.join(", ")})`, `Billing  ${url}`].join("\n"),
+  );
+  if (flags.open && ui.interactive) io.openUrl(url);
+  return EXIT.OK;
+}
+
+async function packs(ctx) {
+  const body = await ctx.client.call("packs");
+  const lines = (body.packs ?? []).map(
+    (p) => `  ${p.key.padEnd(14)} ${String(p.credits).padStart(5)} credits  ${p.prices?.usd === undefined ? "" : dollars(p.prices.usd / 100)}`,
+  );
+  ctx.ui.result(body, ["Credit packs (syndai billing buy <pack>):", ...lines].join("\n"));
+  return EXIT.OK;
+}
+
+async function buy(ctx, pack) {
+  if (!pack) throw new CliError(EXIT.USAGE, "Which pack? syndai billing buy <pack>", { next: "syndai billing packs" });
+  const packKey = pack.startsWith("pack_") ? pack : `pack_${pack}`;
+  const { checkout_url: url } = await ctx.client.call("packCheckout", {
+    body: { pack_key: packKey, country: buyerCountry(ctx) },
+  });
+  return checkout(ctx, url);
+}
+
+async function plan(ctx, tier) {
+  if (!tier) throw new CliError(EXIT.USAGE, "Which plan? syndai billing plan <tier> [--interval month|year]");
+  const interval = ctx.flags.interval ?? "month";
+  if (!["month", "year"].includes(interval)) throw new CliError(EXIT.USAGE, "--interval is month or year.");
+  const { checkout_url: url } = await ctx.client.call("planCheckout", {
+    body: { plan_code: tier.startsWith("tier_") ? tier : `tier_${tier}`, interval, country: buyerCountry(ctx) },
+  });
+  return checkout(ctx, url);
+}
+
+function checkout(ctx, url) {
+  return handOff(ctx, url, "A person pays on this page; nothing is charged until then.", { checkout_url: url });
+}
+
+/**
+ * The billing country a checkout is priced in (ISO alpha-2): `--country`, else the locale's
+ * region, else US. A claim only: the provider's billing address re-checks it.
+ */
+function buyerCountry({ flags, io }) {
+  if (flags.country !== undefined) {
+    if (!/^[A-Za-z]{2}$/.test(flags.country)) throw new CliError(EXIT.USAGE, "--country is a two-letter code, like US or DE.");
+    return flags.country.toUpperCase();
+  }
+  const locale = io.env.LC_ALL || io.env.LC_MONETARY || io.env.LANG || "";
+  return /^[a-z]{2,3}_([A-Z]{2})\b/.exec(locale)?.[1] ?? "US";
+}

package/src/projects.js

@@ -28,7 +28,8 @@ export async function listProjects(ctx) {
       full_name: repo.full_name,
       live_url: app?.url ?? null,
       slug: app?.publication?.slug ?? null,
-      repo_urls: [repo.repo_url, repo.clone_url, repo.html_url].filter(Boolean),
+      // A local clone can only be of a GitHub repo (Syndai-hosted ones are never cloned).
+      remote: repo.provider === "github" ? normalizeRemote(`github.com/${repo.full_name}`) : null,
       protected_paths: repo.protected_paths ?? [],
       customer_id: customerId,
     };
@@ -84,7 +85,7 @@ export async function resolveProject(ctx, { app, required = true, picker = true,
     }
   }
   const remotes = gitRemotes(io.cwd);
-  const byRemote = projects.filter((p) => p.repo_urls.some((u) => remotes.has(normalizeRemote(u))));
+  const byRemote = projects.filter((p) => p.remote && remotes.has(p.remote));
   if (byRemote.length === 1) return byRemote[0];
   if (projects.length === 1) return projects[0];
   if (picker && ui.interactive && projects.length > 1) return pickInteractively(ctx, projects);
@@ -197,3 +198,20 @@ export async function link(ctx, ref) {
   );
   return EXIT.OK;
 }
+
+/** `syndai publish [--app A]`: put the project's default branch live as a hosted app. */
+export async function publish(ctx) {
+  const project = await resolveProject(ctx, { app: ctx.flags.app });
+  // A call while a deploy is in flight answers that deploy, so a retry never starts a second.
+  const { publication } = await ctx.client.call("publishApp", {
+    params: { customer_id: project.customer_id, coding_repository_id: project.id },
+    retry: true,
+  });
+  const url = publication?.url ?? project.live_url;
+  ctx.ui.result(
+    { project_id: project.id, url, state: publication?.state ?? null, publication },
+    url ? `Publishing ${projectLabel(project)}: ${url}` : `Publishing ${projectLabel(project)}.`,
+  );
+  if (!ctx.ui.json) ctx.ui.progress(ctx.ui.dim("It is live there once the deploy finishes (a minute or two)."));
+  return EXIT.OK;
+}

package/src/routes.js

@@ -8,6 +8,8 @@ const EXT = "/api/v1/external/coding";
 export const ROUTES = Object.freeze({
   deviceStart: ["POST", "/api/v1/cli/device"],
   deviceToken: ["POST", "/api/v1/cli/device/token"],
+  signup: ["POST", "/api/v1/signup"],
+  signupVerify: ["POST", "/api/v1/signup/verify"],
   me: ["GET", `${EXT}/me`],
   revokeMe: ["DELETE", `${EXT}/me`],
   listRepos: ["GET", `${EXT}/repos`],
@@ -20,8 +22,15 @@ export const ROUTES = Object.freeze({
     "PATCH",
     `${EXT}/customers/{customer_id}/repositories/{coding_repository_id}/publication`,
   ],
-  getBugScan: ["GET", `${EXT}/repositories/{repository_id}/bug-scan`],
-  setBugScan: ["PUT", `${EXT}/repositories/{repository_id}/bug-scan`],
+  publishApp: ["POST", `${EXT}/customers/{customer_id}/repositories/{coding_repository_id}/publish`],
+  usage: ["GET", `${EXT}/usage/current-period`],
+  subscription: ["GET", `${EXT}/purchases/subscription`],
+  packs: ["GET", `${EXT}/purchases/packs`],
+  packCheckout: ["POST", `${EXT}/purchases/pack-checkout`],
+  planCheckout: ["POST", `${EXT}/purchases/subscription-checkout`],
+  listScans: ["GET", `${EXT}/repositories/{repository_id}/scans`],
+  setScanRoutine: ["PUT", `${EXT}/repositories/{repository_id}/scans`],
+  runScanNow: ["POST", `${EXT}/repositories/{repository_id}/scans/{kind}/run`],
   getPolicy: ["GET", `${EXT}/policy/defaults`],
   putPolicy: ["PUT", `${EXT}/policy/defaults`],
   imageIngest: ["POST", `${EXT}/runs/image-ingest`],
@@ -36,7 +45,10 @@ export const ROUTES = Object.freeze({
   landRetry: ["POST", `${EXT}/runs/{run_id}/land/retry`],
   landClose: ["POST", `${EXT}/runs/{run_id}/land/close`],
   goLive: ["POST", `${EXT}/runs/{run_id}/land/go-live`],
+  landBranch: ["POST", `${EXT}/repos/{coding_repository_id}/land`],
   heldDiff: ["GET", `${EXT}/runs/{run_id}/land/held-diff`],
+  compareKnowledgeFolder: ["POST", `${EXT}/repos/{coding_repository_id}/knowledge/folders/{name}/manifest`],
+  pushKnowledgeFolderFiles: ["POST", `${EXT}/repos/{coding_repository_id}/knowledge/folders/{name}/files`],
   listSchedules: ["GET", `${EXT}/schedules`],
   createSchedule: ["POST", `${EXT}/schedules`],
   getSchedule: ["GET", `${EXT}/schedules/{schedule_id}`],

package/src/schedules.js

@@ -16,6 +16,9 @@ const PAUSE_REASONS = {
   consecutive_failures: "it failed 5 times in a row",
   invalid_trigger: "its schedule is no longer valid",
 };
+// The fixed, published peg (backend `billing/tier_catalog.USD_PER_CREDIT`): the API stores the
+// per-run cap in USD, the CLI takes and shows it in credits like the portal.
+const USD_PER_CREDIT = 0.25;
 const CADENCE_HELP = 'hourly --at :MM, daily|weekdays --at HH:MM, weekly --at "mon HH:MM", or a 5-field cron';
 
 // --- cadence -------------------------------------------------------------------------------
@@ -106,15 +109,20 @@ function dayIndex(text) {
   return index >= 0 && full[index].startsWith(text) ? index : -1;
 }
 
-/** `--budget 5` -> 5; `--budget none` -> null (no per-run cap) where allowed. */
+/** USD -> credits for display: whole numbers bare, else up to two decimals ("20", "6", "0.08"). */
+function credits(usd) {
+  return String(Math.round((usd / USD_PER_CREDIT) * 100) / 100);
+}
+
+/** `--budget 20` (credits) -> 5 (USD); `--budget none` -> null (no per-run cap) where allowed. */
 function budgetOf(text, { allowNone }) {
   if (text === undefined) return undefined;
   if (allowNone && text.trim().toLowerCase() === "none") return null;
-  const value = Number(text.replace(/^\$/, ""));
+  const value = Number(text);
   if (!Number.isFinite(value) || value <= 0) {
-    throw new CliError(EXIT.USAGE, `--budget is a dollar amount per run${allowNone ? ", or none" : ""}, not "${text}".`);
+    throw new CliError(EXIT.USAGE, `--budget is a number of credits per run${allowNone ? ", or none" : ""}, not "${text}".`);
   }
-  return value;
+  return value * USD_PER_CREDIT;
 }
 
 function triggerOf(ctx, { every, at, tz }) {
@@ -162,7 +170,7 @@ function card(s, occurrences = []) {
   const lines = [`${labelOf(s)} · ${stateOf(s)}`, `"${firstLine(s.prompt)}"`];
   if (s.repo_name) lines.push(`Project ${s.repo_name}`);
   if (s.occurrence_budget_usd !== null && s.occurrence_budget_usd !== undefined) {
-    lines.push(`Cap $${s.occurrence_budget_usd} per run`);
+    lines.push(`Cap ${credits(s.occurrence_budget_usd)} credits per run`);
   }
   if (s.status !== "paused") lines.push(upcomingLine(s));
   lines.push("", occurrences.length ? "History:" : "History: none yet");
@@ -368,7 +376,7 @@ export async function repeat(ctx, [runId]) {
     trigger,
     ...(budget === undefined ? {} : { occurrence_budget_usd: budget }),
   });
-  const cost = typeof run.cost_usd === "number" ? ` (last run cost $${run.cost_usd.toFixed(2)})` : "";
+  const cost = typeof run.cost_usd === "number" ? ` (last run cost ${credits(run.cost_usd)} credits)` : "";
   return printCreated(
     ctx,
     created,

package/src/settings.js

@@ -3,7 +3,7 @@
 // Settings live in four places server-side:
 //   autonomy          repo-scoped policy default       GET/PUT policy/defaults
 //   feature_requests  the app's publication            GET/PATCH .../publication
-//   bug_scan          the repo's Bug Finder schedule   GET/PUT repositories/{id}/bug-scan
+//   bug_scan          the repo's weekly Code bugs check GET/PUT repositories/{id}/scans
 //   protected_paths   the repo row                     PATCH repos/{id} (a key may only tighten)
 
 import { ApiError, CliError, EXIT, explain } from "./errors.js";
@@ -66,9 +66,9 @@ async function apply(ctx, project, { key, op, value }) {
       body: { feature_requests: value },
     });
   } else if (key === "bug_scan") {
-    await client.call("setBugScan", {
+    await client.call("setScanRoutine", {
       params: { repository_id: project.id },
-      body: { enabled: value === "on" },
+      body: { kind: "code", cadence: value === "on" ? "weekly" : "off" },
     });
   } else {
     const added = value
@@ -91,7 +91,7 @@ async function read(ctx, project) {
   const [policy, publication, bugScan] = await Promise.all([
     settle(client.call("getPolicy", { query: { coding_repository_id: project.id } })),
     settle(client.call("getPublication", { params: ids })),
-    settle(client.call("getBugScan", { params: { repository_id: project.id } })),
+    settle(client.call("listScans", { params: { repository_id: project.id } })),
   ]);
   const unavailable = {};
   for (const [key, got] of [
@@ -104,7 +104,7 @@ async function read(ctx, project) {
   return {
     autonomy: policy.value?.config?.autonomy ?? null,
     feature_requests: publication.value?.feature_requests ?? null,
-    bug_scan: bugScan.value ? (bugScan.value.enabled ? "on" : "off") : null,
+    bug_scan: bugScan.value ? codeScan(bugScan.value) : null,
     protected_paths: project.protected_paths,
     unavailable,
   };
@@ -128,3 +128,9 @@ async function orNull(promise) {
     throw err;
   }
 }
+
+// The Code bugs routine is "on" while it runs on a cadence with its spend agreed.
+function codeScan(scans) {
+  const code = (scans.kinds ?? []).find((k) => k.kind === "code");
+  return code && code.cadence !== "off" && !code.needs_consent ? "on" : "off";
+}