@lizard-build/cli 0.1.0 → 0.3.30

package/src/lib/picker.ts

@@ -0,0 +1,133 @@
+import * as p from "@clack/prompts";
+import { api, withQuery, type Workspace } from "./api.js";
+import { isTTY } from "./format.js";
+
+export async function fetchWorkspaces(): Promise<Workspace[]> {
+  return api.get<Workspace[]>("/api/workspaces");
+}
+
+export function matchWorkspace(
+  workspaces: Workspace[],
+  idOrSlugOrName: string,
+): Workspace | undefined {
+  const lower = idOrSlugOrName.toLowerCase();
+  return workspaces.find(
+    (w) =>
+      w.id.toLowerCase() === lower ||
+      w.slug.toLowerCase() === lower ||
+      w.name.toLowerCase() === lower,
+  );
+}
+
+/**
+ * Resolve a workspace by flag value. Fetches the list once; throws with the
+ * available names when the value doesn't match anything the user belongs to.
+ */
+export async function resolveWorkspace(flagValue: string): Promise<Workspace> {
+  const workspaces = await fetchWorkspaces();
+  const match = matchWorkspace(workspaces, flagValue);
+  if (!match) {
+    throw new Error(
+      `Workspace "${flagValue}" not found. Available: ${
+        workspaces.map((w) => w.name).join(", ") || "(none)"
+      }`,
+    );
+  }
+  return match;
+}
+
+/**
+ * Pick a workspace for project creation / linking.
+ *
+ *   1. --workspace flag wins.
+ *   2. If only one workspace exists, auto-select it.
+ *   3. Non-TTY → prefer personal, else first.
+ *   4. TTY → prompt.
+ *
+ * `projectNameHint` lets the caller short-circuit when --name X uniquely
+ * identifies a workspace (see init flow case 5).
+ */
+export async function pickWorkspace(opts: {
+  flag?: string;
+  projectNameHint?: string;
+  workspaces?: Workspace[];
+}): Promise<Workspace> {
+  if (opts.flag) return resolveWorkspace(opts.flag);
+
+  const list = opts.workspaces ?? (await fetchWorkspaces());
+  if (list.length === 0) {
+    throw new Error(
+      "No workspaces available. The backend should always return a personal workspace — please report this.",
+    );
+  }
+  if (list.length === 1) return list[0];
+
+  // Hint-based auto-pick: a --name match that is unique across workspaces.
+  if (opts.projectNameHint) {
+    const matches = await findWorkspacesContainingProject(
+      list,
+      opts.projectNameHint,
+    );
+    if (matches.length === 1) return matches[0].workspace;
+    if (matches.length > 1) {
+      const detail = matches
+        .map((m) => `  • ${m.project.name}  in ${m.workspace.name}  (--workspace ${m.workspace.slug})`)
+        .join("\n");
+      throw new Error(
+        `Multiple projects named "${opts.projectNameHint}" found:\n${detail}\nPass --workspace, or run \`lizard init\` without --name to choose interactively.`,
+      );
+    }
+  }
+
+  if (!isTTY()) {
+    // Non-TTY fallback: personal first, else first ws.
+    const personal = list.find((w) => w.isPersonal);
+    return personal ?? list[0];
+  }
+
+  const sel = await p.select({
+    message: "Workspace",
+    options: list.map((w) => ({
+      value: w.id,
+      label: w.name,
+      hint: `${w.role}${w.isPersonal ? " · personal" : ""} · ${w.projectCount ?? 0} project${(w.projectCount ?? 0) === 1 ? "" : "s"}`,
+    })),
+  });
+  if (p.isCancel(sel)) process.exit(5);
+  return list.find((w) => w.id === sel)!;
+}
+
+interface ProjectLite {
+  id: string;
+  name: string;
+  slug: string;
+  workspaceId?: string | null;
+}
+
+async function findWorkspacesContainingProject(
+  workspaces: Workspace[],
+  nameOrSlugOrId: string,
+): Promise<Array<{ workspace: Workspace; project: ProjectLite }>> {
+  const all = await api.get<ProjectLite[]>("/api/projects");
+  const lower = nameOrSlugOrId.toLowerCase();
+  const matches: Array<{ workspace: Workspace; project: ProjectLite }> = [];
+  for (const w of workspaces) {
+    const inWs = all.find(
+      (pr) =>
+        pr.workspaceId === w.id &&
+        (pr.id.toLowerCase() === lower ||
+          pr.slug.toLowerCase() === lower ||
+          pr.name.toLowerCase() === lower),
+    );
+    if (inWs) matches.push({ workspace: w, project: inWs });
+  }
+  return matches;
+}
+
+export async function listProjectsInWorkspace(
+  workspaceId: string,
+): Promise<ProjectLite[]> {
+  return api.get<ProjectLite[]>(
+    withQuery("/api/projects", { workspaceId }),
+  );
+}

package/src/lib/resolve.ts

@@ -0,0 +1,285 @@
+import { api, withScope, type ResourceScope } from "./api.js";
+import {
+  getProjectLink,
+  resolveProjectId,
+  updateProjectLink,
+} from "./config.js";
+
+/**
+ * Build a ResourceScope for an arbitrary project. When the project matches the
+ * cwd link, reuse its workspaceId (no extra round-trip). Otherwise fetch the
+ * project's workspace once so cross-project commands (`-p other-project`) still
+ * get `?workspaceId=…` on the request — without it the backend can 404 a
+ * project the user reaches via workspace membership.
+ */
+export async function scopeForProject(projectId: string): Promise<ResourceScope> {
+  const link = getProjectLink();
+  if (link?.projectId === projectId && link.workspaceId) {
+    return { workspaceId: link.workspaceId };
+  }
+  const fetched = await lookupProjectWorkspace(projectId);
+  return { workspaceId: fetched?.workspaceId ?? null };
+}
+
+interface AppLite {
+  id: string;
+  name: string;
+  status?: string;
+}
+
+interface AddonLite {
+  id: string;
+  name: string;
+  addonType?: string;
+  status?: string;
+}
+
+interface ServicesResponse {
+  apps?: AppLite[];
+  addons?: AddonLite[];
+}
+
+/**
+ * Resolve a service (app or addon) within a project. Match by ID or name.
+ * Throws with a helpful list of available services when not found.
+ */
+export async function resolveService(
+  projectId: string,
+  nameOrId: string,
+): Promise<{ id: string; name: string; kind: "app" | "addon" }> {
+  const data = await api.get<ServicesResponse>(
+    withScope(`/api/projects/${projectId}/services`, await scopeForProject(projectId)),
+  );
+
+  const apps = data.apps || [];
+  const addons = data.addons || [];
+
+  const lower = nameOrId.toLowerCase();
+
+  const app = apps.find(
+    (a) => a.id.toLowerCase() === lower || a.name?.toLowerCase() === lower,
+  );
+  if (app) return { id: app.id, name: app.name, kind: "app" };
+
+  const addon = addons.find(
+    (a) =>
+      a.id.toLowerCase() === lower ||
+      a.name?.toLowerCase() === lower ||
+      a.addonType?.toLowerCase() === lower,
+  );
+  if (addon) {
+    return { id: addon.id, name: addon.name || addon.addonType || "", kind: "addon" };
+  }
+
+  const available = [
+    ...apps.map((a) => a.name),
+    ...addons.map((a) => a.name || a.addonType),
+  ].filter(Boolean);
+
+  throw new Error(
+    `Service "${nameOrId}" not found in project. ` +
+      (available.length ? `Available: ${available.join(", ")}` : "No services exist."),
+  );
+}
+
+/**
+ * Pick the active service for a command:
+ *   1. --service flag (resolve by name/id)
+ *   2. linked service in cwd
+ *   3. throw with hint to pass --service
+ */
+export async function getActiveService(
+  serviceFlag: string | undefined,
+  projectId: string,
+): Promise<{ id: string; name: string }> {
+  if (serviceFlag) {
+    const resolved = await resolveService(projectId, serviceFlag);
+    return { id: resolved.id, name: resolved.name };
+  }
+
+  const link = getProjectLink();
+  if (link?.serviceId) {
+    return {
+      id: link.serviceId,
+      name: link.serviceName || link.serviceId,
+    };
+  }
+
+  throw new Error(
+    "No service specified. Pass --service <name> or run `lizard service link <name>`.",
+  );
+}
+
+/**
+ * Same as `getActiveService`, but also returns whether the target is an app
+ * or an addon. Costs one extra `/services` lookup when the service is taken
+ * from the cwd link (which otherwise resolves locally), so use this only when
+ * the caller branches on kind (e.g. `lizard scale`).
+ */
+export async function getActiveServiceWithKind(
+  serviceFlag: string | undefined,
+  projectId: string,
+): Promise<{ id: string; name: string; kind: "app" | "addon" }> {
+  if (serviceFlag) {
+    return resolveService(projectId, serviceFlag);
+  }
+
+  const link = getProjectLink();
+  if (link?.serviceId) {
+    const data = await api.get<ServicesResponse>(
+      withScope(`/api/projects/${projectId}/services`, await scopeForProject(projectId)),
+    );
+    const app = data.apps?.find((a) => a.id === link.serviceId);
+    if (app) return { id: app.id, name: app.name, kind: "app" };
+    const addon = data.addons?.find((a) => a.id === link.serviceId);
+    if (addon) {
+      return {
+        id: addon.id,
+        name: addon.name || addon.addonType || link.serviceName || link.serviceId,
+        kind: "addon",
+      };
+    }
+    throw new Error(
+      `Linked service "${link.serviceName || link.serviceId}" no longer exists in this project.`,
+    );
+  }
+
+  throw new Error(
+    "No service specified. Pass --service <name> or run `lizard service link <name>`.",
+  );
+}
+
+/**
+ * Look up the workspace id for a project. Used to lazy-fill legacy links
+ * that were saved before workspaces existed. Returns null if the project
+ * isn't accessible to the current user.
+ */
+export async function lookupProjectWorkspace(
+  projectId: string,
+): Promise<{ workspaceId?: string | null; workspaceName?: string | null } | null> {
+  try {
+    const proj = await api.get<{
+      workspaceId?: string | null;
+      workspaceName?: string | null;
+    }>(`/api/projects/${projectId}`);
+    return {
+      workspaceId: proj.workspaceId ?? null,
+      workspaceName: proj.workspaceName ?? null,
+    };
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Resolve a project flag → `{ projectId, scope }`. Scope carries
+ * workspaceId for `withScope(url, scope)` queries.
+ *
+ * For the linked project, lazy-fills missing workspaceId into the cwd link.
+ * For a different project (`-p other-project`), fetches the target's
+ * workspace so the scope reflects the target — not whatever the cwd link
+ * happened to be pointing at.
+ */
+export async function resolveProjectScope(
+  projectFlag?: string,
+): Promise<{ projectId: string; scope: ResourceScope }> {
+  const projectId = await resolveProjectId(projectFlag);
+  const link = getProjectLink();
+
+  // Same project as the cwd link — reuse cached workspaceId, lazy-fill if missing.
+  if (link?.projectId === projectId) {
+    let workspaceId: string | null | undefined = link.workspaceId ?? null;
+    let workspaceName: string | undefined = link.workspaceName;
+    if (!workspaceId) {
+      const fetched = await lookupProjectWorkspace(projectId);
+      if (fetched?.workspaceId) {
+        workspaceId = fetched.workspaceId;
+        workspaceName = fetched.workspaceName ?? undefined;
+        try {
+          updateProjectLink({ workspaceId, workspaceName });
+        } catch {}
+      }
+    }
+    return { projectId, scope: { workspaceId: workspaceId ?? null } };
+  }
+
+  // Different project — never reuse the link's workspaceId. Look up the
+  // target project's workspace directly. Mirrors `scopeForProject`.
+  const scope = await scopeForProject(projectId);
+  return { projectId, scope };
+}
+
+export interface ResolvedContext {
+  projectId: string;
+  workspaceId?: string;
+  workspaceName?: string;
+  service?: { id: string; name: string };
+}
+
+/** Build the scope object for `withScope(url, scope)` API calls. */
+export function getScope(ctx: ResolvedContext): ResourceScope {
+  return {
+    workspaceId: ctx.workspaceId ?? null,
+  };
+}
+
+/**
+ * Convenience: resolve project + active service in one go.
+ *
+ * Lazily backfills `workspaceId` into the cwd link when missing (legacy
+ * configs written before workspaces existed). Once filled, subsequent
+ * commands get the scope param for free.
+ */
+export async function resolveContext(opts: {
+  projectFlag?: string;
+  serviceFlag?: string;
+  workspaceFlag?: string;
+  requireService?: boolean;
+}): Promise<ResolvedContext> {
+  const projectId = await resolveProjectId(opts.projectFlag);
+
+  let service: { id: string; name: string } | undefined;
+  const link = getProjectLink();
+  if (opts.serviceFlag || opts.requireService) {
+    service = await getActiveService(opts.serviceFlag, projectId);
+  } else if (link?.serviceId) {
+    service = {
+      id: link.serviceId,
+      name: link.serviceName || link.serviceId,
+    };
+  }
+
+  // Workspace resolution: only reuse the link's workspaceId when it
+  // describes the same project. For cross-project commands we fetch the
+  // target project's workspace so the scope is correct — using the link's
+  // ws here would scope into the wrong workspace.
+  let workspaceId: string | undefined;
+  let workspaceName: string | undefined;
+  if (link?.projectId === projectId) {
+    workspaceId = link.workspaceId;
+    workspaceName = link.workspaceName;
+    if (!workspaceId) {
+      const fetched = await lookupProjectWorkspace(projectId);
+      if (fetched?.workspaceId) {
+        workspaceId = fetched.workspaceId;
+        workspaceName = fetched.workspaceName ?? undefined;
+        try {
+          updateProjectLink({ workspaceId, workspaceName });
+        } catch {
+          // Non-fatal: link may not exist for this cwd (e.g. --project flag).
+        }
+      }
+    }
+  } else {
+    const fetched = await lookupProjectWorkspace(projectId);
+    workspaceId = fetched?.workspaceId ?? undefined;
+    workspaceName = fetched?.workspaceName ?? undefined;
+  }
+
+  return {
+    projectId,
+    workspaceId,
+    workspaceName,
+    service,
+  };
+}

package/src/lib/updater.ts

@@ -0,0 +1,106 @@
+import { createWriteStream, existsSync, renameSync, chmodSync } from "node:fs";
+import { pipeline } from "node:stream/promises";
+import { Readable } from "node:stream";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { execFileSync } from "node:child_process";
+
+export const CURRENT_VERSION = "0.3.30";
+const RELEASES_API = "https://api.github.com/repos/lizard-build/lizard-cli/releases/latest";
+const RELEASE_BASE = "https://github.com/lizard-build/lizard-cli/releases/latest/download";
+
+function getBinaryName(): string | null {
+  const os = process.platform;
+  const arch = process.arch;
+  if (os === "darwin" && arch === "arm64") return "lizard-darwin-arm64";
+  if (os === "darwin" && arch === "x64") return "lizard-darwin-x64";
+  if (os === "linux" && arch === "x64") return "lizard-linux-x64";
+  if (os === "linux" && arch === "arm64") return "lizard-linux-arm64";
+  return null;
+}
+
+export type LatestVersionResult =
+  | { kind: "ok"; version: string }
+  | { kind: "rate-limited"; resetAt: number }
+  | { kind: "error" };
+
+export async function getLatestVersion(): Promise<LatestVersionResult> {
+  try {
+    const res = await fetch(RELEASES_API, {
+      headers: { "User-Agent": "lizard-cli" },
+      signal: AbortSignal.timeout(5000),
+    });
+    if (res.status === 403 && res.headers.get("x-ratelimit-remaining") === "0") {
+      const reset = Number(res.headers.get("x-ratelimit-reset"));
+      return { kind: "rate-limited", resetAt: Number.isFinite(reset) ? reset : 0 };
+    }
+    if (!res.ok) return { kind: "error" };
+    const data = (await res.json()) as { tag_name?: string };
+    const version = data.tag_name?.replace(/^v/, "");
+    return version ? { kind: "ok", version } : { kind: "error" };
+  } catch {
+    return { kind: "error" };
+  }
+}
+
+export async function selfUpdate(onProgress?: (msg: string) => void): Promise<boolean> {
+  const binaryName = getBinaryName();
+  if (!binaryName) return false;
+
+  // Find current executable path
+  const currentBin = process.execPath;
+  if (!existsSync(currentBin)) return false;
+
+  const url = `${RELEASE_BASE}/${binaryName}`;
+  const tmp = join(tmpdir(), `lizard-update-${Date.now()}`);
+
+  onProgress?.(`Downloading ${binaryName}...`);
+
+  const res = await fetch(url, { signal: AbortSignal.timeout(60000) });
+  if (!res.ok) throw new Error(`Download failed: ${res.status}`);
+
+  const writer = createWriteStream(tmp);
+  await pipeline(Readable.fromWeb(res.body as any), writer);
+  chmodSync(tmp, 0o755);
+
+  onProgress?.("Installing...");
+  renameSync(tmp, currentBin);
+  return true;
+}
+
+/** Check for a newer version and auto-install it in the background.
+ *  Prints a one-line notice on exit — either "Updated to vX.Y.Z" or nothing on failure.
+ *  Never blocks or crashes the current command. */
+export function checkForUpdateInBackground(): void {
+  // Only auto-update in TTY; skip CI / piped output
+  if (!process.stdout.isTTY) return;
+
+  let updateMessage: string | null = null;
+
+  const promise = getLatestVersion().then(async (r) => {
+    if (r.kind !== "ok") return;
+    const latest = r.version;
+    if (latest === CURRENT_VERSION) return;
+    const [maj, min, pat] = latest.split(".").map(Number);
+    const [cmaj, cmin, cpat] = CURRENT_VERSION.split(".").map(Number);
+    const isNewer = maj > cmaj || (maj === cmaj && min > cmin) || (maj === cmaj && min === cmin && pat > cpat);
+    if (!isNewer) return;
+    try {
+      const ok = await selfUpdate();
+      if (ok) {
+        updateMessage =
+          `\n  Updating lizard v${CURRENT_VERSION} → v${latest}...\n` +
+          `  lizard updated to v${latest}\n`;
+      }
+    } catch {
+      // silent — don't interrupt the current command
+    }
+  }).catch(() => {});
+
+  process.on("exit", () => {
+    if (updateMessage) process.stderr.write(updateMessage);
+  });
+
+  // Don't block process exit
+  if (typeof (promise as any).unref === "function") (promise as any).unref();
+}