@runfusion/fusion 0.26.0 → 0.27.0

package/dist/plugins/fusion-plugin-cli-printing-press/src/manage-view.tsx

@@ -0,0 +1,122 @@
+import type { PluginDashboardViewContext } from "@fusion/dashboard/app/plugins/types";
+import { List, Pencil, RefreshCw, Trash2 } from "lucide-react";
+import { useEffect, useMemo, useState } from "react";
+import { EditDraftModal } from "./manage/EditDraftModal.js";
+import { useDrafts } from "./manage/useDrafts.js";
+import { CliPrintingPressTestRunner } from "./run/TestRunnerPanel.js";
+import type { ServiceDraft } from "./wizard/types.js";
+import "./manage-view.css";
+
+// FN-3763 symbol drift note: plugin id/registry route uses "fusion-plugin-cli-printing-press"
+// and bundled registration lives in registerBundledPluginViews.ts (not pluginViewRegistry.tsx).
+export function CliPrintingPressManageView({ context: _context }: { context?: PluginDashboardViewContext }) {
+  const { drafts, loading, error, refresh, getDraft, updateDraft, regenerateDraft, deleteDraft } = useDrafts();
+  const [selectedId, setSelectedId] = useState<string | null>(null);
+  const [selectedDraft, setSelectedDraft] = useState<ServiceDraft | null>(null);
+  const [detailError, setDetailError] = useState<string | null>(null);
+  const [statusMessage, setStatusMessage] = useState<string | null>(null);
+  const [isEditOpen, setIsEditOpen] = useState(false);
+
+  useEffect(() => {
+    if (!drafts.length) {
+      setSelectedId(null);
+      setSelectedDraft(null);
+      return;
+    }
+    const activeId = selectedId && drafts.some((item) => item.id === selectedId) ? selectedId : drafts[0]?.id ?? null;
+    setSelectedId(activeId);
+  }, [drafts, selectedId]);
+
+  useEffect(() => {
+    if (!selectedId) return;
+    void (async () => {
+      try {
+        setDetailError(null);
+        setSelectedDraft(await getDraft(selectedId));
+      } catch (err) {
+        setDetailError(err instanceof Error ? err.message : "Failed to load draft details");
+      }
+    })();
+  }, [getDraft, selectedId]);
+
+  const selectedListItem = useMemo(() => drafts.find((item) => item.id === selectedId) ?? null, [drafts, selectedId]);
+
+  async function onRegenerate() {
+    if (!selectedId) return;
+    try {
+      const response = await regenerateDraft(selectedId);
+      setSelectedDraft(response.draft);
+      setStatusMessage(`Regenerated at ${new Date(response.artifact.generatedAt).toLocaleString()}`);
+      await refresh();
+    } catch (err) {
+      setStatusMessage(err instanceof Error ? err.message : "Failed to regenerate draft");
+    }
+  }
+
+  async function onDelete() {
+    if (!selectedId) return;
+    if (!globalThis.confirm("Delete this draft?")) return;
+    try {
+      await deleteDraft(selectedId);
+      setStatusMessage("Draft removed");
+      await refresh();
+    } catch (err) {
+      setStatusMessage(err instanceof Error ? err.message : "Failed to delete draft");
+    }
+  }
+
+  async function onSaveEditedDraft(nextDraft: ServiceDraft) {
+    if (!selectedId) return;
+    const saved = await updateDraft(selectedId, nextDraft);
+    setSelectedDraft(saved);
+    setIsEditOpen(false);
+    setStatusMessage("Draft updated");
+    await refresh();
+  }
+
+  if (loading) return <section className="card cli-press-manage-state"><p>Loading drafts…</p></section>;
+  if (error) return <section className="card cli-press-manage-state"><p className="form-error">{error}</p></section>;
+
+  return (
+    <section className="cli-press-manage">
+      <header className="cli-press-manage-header">
+        <h2><List /> Manage Service CLIs</h2>
+      </header>
+      {statusMessage ? <p className="cli-press-manage-status">{statusMessage}</p> : null}
+      {!drafts.length ? <div className="card"><p>No saved drafts yet. Use the Create Service CLI view to add one.</p></div> : (
+        <div className="cli-press-manage-layout">
+          <div className="cli-press-manage-list">
+            {drafts.map((draft) => (
+              <button key={draft.id} className={`card cli-press-manage-row${draft.id === selectedId ? " is-selected" : ""}`} onClick={() => setSelectedId(draft.id)}>
+                <div className="cli-press-manage-row-title">{draft.name || draft.slug}</div>
+                <div className="cli-press-manage-row-meta">{draft.slug} • {new Date(draft.updatedAt).toLocaleString()}</div>
+              </button>
+            ))}
+          </div>
+          <div className="card cli-press-manage-detail">
+            {detailError ? <p className="form-error">{detailError}</p> : null}
+            {selectedDraft ? (
+              <>
+                <h3>{selectedDraft.name}</h3>
+                <p><strong>Slug:</strong> {selectedListItem?.slug}</p>
+                <p><strong>Base URL:</strong> {selectedDraft.baseUrl}</p>
+                <p><strong>Endpoints:</strong> {selectedDraft.endpoints.length}</p>
+                <p><strong>Credentials:</strong> {selectedDraft.credential.kind}</p>
+                <p><strong>Updated:</strong> {new Date(selectedDraft.updatedAt).toLocaleString()}</p>
+                <div className="cli-press-manage-actions">
+                  <button className="btn" onClick={() => setIsEditOpen(true)}><Pencil /> Edit</button>
+                  <button className="btn" onClick={() => void onRegenerate()}><RefreshCw /> Regenerate</button>
+                  <button className="btn btn-danger" onClick={() => void onDelete()}><Trash2 /> Delete</button>
+                </div>
+                <CliPrintingPressTestRunner draftId={selectedDraft.id} draft={selectedDraft} />
+              </>
+            ) : <p>Select a draft to inspect details.</p>}
+          </div>
+        </div>
+      )}
+      {isEditOpen && selectedDraft ? <EditDraftModal initialDraft={selectedDraft} onClose={() => setIsEditOpen(false)} onSave={onSaveEditedDraft} /> : null}
+    </section>
+  );
+}
+
+export default CliPrintingPressManageView;

package/dist/plugins/fusion-plugin-cli-printing-press/src/routes/wizard-routes.ts

@@ -0,0 +1,272 @@
+import type { PluginContext, PluginRouteDefinition, PluginRouteResult } from "@fusion/core";
+import { generateCli } from "../generation/generator.js";
+import { runGeneratedCli } from "../generation/runner.js";
+import type { GeneratedCliArtifact, RunRequest } from "../generation/types.js";
+import { createCliPressStore } from "../store/cli-press-store.js";
+import type { CliSpec, Service } from "../store/cli-press-types.js";
+import type { ServiceDraft } from "../wizard/types.js";
+import { validateDraft } from "../wizard/validation.js";
+
+interface RouteRequest {
+  params: Record<string, string>;
+  body?: unknown;
+}
+
+function asRequest(req: unknown): RouteRequest { return req as RouteRequest; }
+function ok(body: unknown, status = 200): PluginRouteResult { return { status, body }; }
+
+function asArtifact(draft: ServiceDraft): GeneratedCliArtifact | null {
+  if (!draft.artifactPath || !draft.generatedAt) return null;
+  return {
+    draftId: draft.id,
+    slug: draft.slug,
+    binPath: draft.artifactPath,
+    entrypoint: "node",
+    generatedAt: draft.generatedAt,
+  };
+}
+
+function getArtifactDir(id: string, projectRoot: string): string {
+  return `${projectRoot}/.fusion/plugins/cli-printing-press/artifacts/${id}`;
+}
+
+function getStore(ctx: PluginContext) {
+  return createCliPressStore(ctx.taskStore.getDatabase());
+}
+
+function toDraft(service: Service, spec: CliSpec | undefined, endpoints: ServiceDraft["endpoints"]): ServiceDraft {
+  return {
+    id: service.id,
+    name: service.displayName,
+    slug: service.slug,
+    description: service.description ?? "",
+    baseUrl: service.baseUrl,
+    transport: "http",
+    endpoints,
+    credential: { kind: "none" },
+    createdAt: service.createdAt,
+    updatedAt: service.updatedAt,
+    generatedAt: spec?.generatedAt,
+    regeneratedAt: spec?.generatedAt,
+    artifactPath: spec?.status === "generated" ? spec.specJson : undefined,
+  };
+}
+
+function isPrimitive(value: unknown): value is string | number | boolean {
+  return typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+}
+
+function validateRunRequest(body: unknown): { ok: true; value: RunRequest } | { ok: false; error: string } {
+  if (!body || typeof body !== "object") return { ok: false, error: "Request body is required" };
+  const candidate = body as Record<string, unknown>;
+  if (typeof candidate.endpointId !== "string" || !candidate.endpointId.trim()) return { ok: false, error: "endpointId is required" };
+  if (!candidate.params || typeof candidate.params !== "object" || Array.isArray(candidate.params)) return { ok: false, error: "params must be an object" };
+  for (const value of Object.values(candidate.params as Record<string, unknown>)) {
+    if (!isPrimitive(value)) return { ok: false, error: "params values must be primitives" };
+  }
+  if (candidate.credentials !== undefined) {
+    if (!candidate.credentials || typeof candidate.credentials !== "object" || Array.isArray(candidate.credentials)) return { ok: false, error: "credentials must be an object" };
+    for (const value of Object.values(candidate.credentials as Record<string, unknown>)) {
+      if (typeof value !== "string") return { ok: false, error: "credentials values must be strings" };
+    }
+  }
+  if (candidate.timeoutMs !== undefined) {
+    if (!Number.isFinite(candidate.timeoutMs) || !Number.isInteger(candidate.timeoutMs) || (candidate.timeoutMs as number) <= 0 || (candidate.timeoutMs as number) > 300_000) {
+      return { ok: false, error: "timeoutMs must be an integer between 1 and 300000" };
+    }
+  }
+  return {
+    ok: true,
+    value: {
+      endpointId: candidate.endpointId,
+      params: candidate.params as Record<string, string | number | boolean>,
+      credentials: candidate.credentials as Record<string, string> | undefined,
+      timeoutMs: candidate.timeoutMs as number | undefined,
+    },
+  };
+}
+
+export function createCliPrintingPressRoutes(): PluginRouteDefinition[] {
+  return [
+    {
+      method: "POST",
+      path: "/drafts",
+      handler: async (req, ctx: PluginContext) => {
+        const request = asRequest(req);
+        const draft = request.body as ServiceDraft;
+        const result = validateDraft(draft);
+        if (!result.ok) return { status: 400, body: { error: Object.values(result.errors)[0] ?? "Validation failed", errors: result.errors } };
+        const store = getStore(ctx);
+        const createdService = store.createService({
+          slug: draft.slug,
+          displayName: draft.name,
+          description: draft.description,
+          baseUrl: draft.baseUrl,
+          sourceKind: "manual",
+          sourceRef: undefined,
+        });
+        const createdSpec = store.createSpec({
+          serviceId: createdService.id,
+          name: `${draft.slug}-cli`,
+          version: "0.1.0",
+          generatorVersion: "cli-printing-press",
+          specJson: JSON.stringify(draft),
+          status: "draft",
+          generatedAt: undefined,
+          lastGenerationError: undefined,
+        });
+        store.setSetting({ serviceId: createdService.id, key: "endpoints", value: JSON.stringify(draft.endpoints), scope: "wizard" });
+        const created = toDraft(createdService, createdSpec, draft.endpoints);
+        return ok(created, 201);
+      },
+    },
+    {
+      method: "GET",
+      path: "/drafts",
+      handler: async (_req, ctx: PluginContext) => {
+        const store = getStore(ctx);
+        const drafts = store.listServices().map((service) => ({
+          id: service.id,
+          name: service.displayName,
+          slug: service.slug,
+          updatedAt: service.updatedAt,
+        }));
+        return ok(drafts);
+      },
+    },
+    {
+      method: "GET",
+      path: "/drafts/:id",
+      handler: async (req, ctx: PluginContext) => {
+        const request = asRequest(req);
+        const store = getStore(ctx);
+        const service = store.getService(request.params.id);
+        if (!service) return ok({ error: "Draft not found" }, 404);
+        const spec = store.listSpecs(service.id)[0];
+        const endpointsSetting = store.listSettings(service.id).find((entry) => entry.key === "endpoints" && entry.scope === "wizard");
+        const endpoints = endpointsSetting ? (JSON.parse(endpointsSetting.value) as ServiceDraft["endpoints"]) : [];
+        return ok(toDraft(service, spec, endpoints));
+      },
+    },
+    {
+      method: "PUT",
+      path: "/drafts/:id",
+      handler: async (req, ctx: PluginContext) => {
+        const request = asRequest(req);
+        const draft = request.body as ServiceDraft;
+        const result = validateDraft(draft);
+        if (!result.ok) return { status: 400, body: { error: Object.values(result.errors)[0] ?? "Validation failed", errors: result.errors } };
+        const store = getStore(ctx);
+        const service = store.getService(request.params.id);
+        if (!service) return ok({ error: "Draft not found" }, 404);
+        const updatedService = store.updateService(service.id, {
+          displayName: draft.name,
+          description: draft.description,
+          baseUrl: draft.baseUrl,
+          sourceKind: "manual",
+        });
+        const existingSpec = store.listSpecs(service.id)[0];
+        const updatedSpec = existingSpec
+          ? store.updateSpec(existingSpec.id, { specJson: JSON.stringify(draft), status: "draft", lastGenerationError: undefined })
+          : store.createSpec({
+            serviceId: service.id,
+            name: `${draft.slug}-cli`,
+            version: "0.1.0",
+            generatorVersion: "cli-printing-press",
+            specJson: JSON.stringify(draft),
+            status: "draft",
+            generatedAt: undefined,
+            lastGenerationError: undefined,
+          });
+        store.setSetting({ serviceId: service.id, key: "endpoints", value: JSON.stringify(draft.endpoints), scope: "wizard" });
+        return ok(toDraft(updatedService, updatedSpec, draft.endpoints));
+      },
+    },
+    {
+      method: "POST",
+      path: "/drafts/:id/regenerate",
+      handler: async (req, ctx: PluginContext) => {
+        const request = asRequest(req);
+        const projectRoot = ctx.taskStore.getRootDir();
+        const store = getStore(ctx);
+        const service = store.getService(request.params.id);
+        if (!service) return ok({ error: "Draft not found" }, 404);
+        const spec = store.listSpecs(service.id)[0];
+        if (!spec) return ok({ error: "Draft not found" }, 404);
+        const draft = JSON.parse(spec.specJson) as ServiceDraft;
+        const artifact = await generateCli({ draft, outDir: getArtifactDir(draft.id, projectRoot) });
+        const updatedSpec = store.updateSpec(spec.id, {
+          specJson: JSON.stringify({ ...draft, regeneratedAt: artifact.generatedAt, generatedAt: artifact.generatedAt, artifactPath: artifact.binPath }),
+          generatedAt: artifact.generatedAt,
+          status: "generated",
+          lastGenerationError: undefined,
+        });
+        store.createArtifact({
+          cliSpecId: spec.id,
+          kind: "script",
+          path: artifact.binPath.replace(`${projectRoot}/.fusion/`, ""),
+          executable: true,
+          checksum: undefined,
+          sizeBytes: undefined,
+        });
+        return ok({ draft: JSON.parse(updatedSpec.specJson) as ServiceDraft, artifact });
+      },
+    },
+    {
+      method: "POST",
+      path: "/drafts/:id/run",
+      handler: async (req, ctx: PluginContext) => {
+        const request = asRequest(req);
+        const parsed = validateRunRequest(request.body);
+        if (!parsed.ok) return ok({ error: parsed.error }, 400);
+
+        const store = getStore(ctx);
+        const service = store.getService(request.params.id);
+        if (!service) return ok({ error: "Draft not found" }, 404);
+        const spec = store.listSpecs(service.id)[0];
+        if (!spec) return ok({ error: "Draft not found" }, 404);
+        const draft = JSON.parse(spec.specJson) as ServiceDraft;
+        const artifact = asArtifact(draft);
+        if (!artifact) return ok({ error: "Draft has not been generated yet" }, 409);
+
+        const endpointExists = draft.endpoints.some((endpoint) => endpoint.id === parsed.value.endpointId);
+        if (!endpointExists) return ok({ error: "Endpoint not found" }, 400);
+
+        const result = await runGeneratedCli({
+          artifact,
+          endpointId: parsed.value.endpointId,
+          params: parsed.value.params,
+          credentials: parsed.value.credentials,
+          timeoutMs: parsed.value.timeoutMs,
+          cwd: ctx.taskStore.getRootDir(),
+        });
+        return ok(result, 200);
+      },
+    },
+    {
+      method: "GET",
+      path: "/drafts/:id/artifact",
+      handler: async (req, ctx: PluginContext) => {
+        const request = asRequest(req);
+        const store = getStore(ctx);
+        const service = store.getService(request.params.id);
+        if (!service) return ok({ error: "Artifact not found" }, 404);
+        const spec = store.listSpecs(service.id)[0];
+        if (!spec) return ok({ error: "Artifact not found" }, 404);
+        const draft = JSON.parse(spec.specJson) as ServiceDraft;
+        const artifact = asArtifact(draft);
+        return artifact ? ok({ artifact }) : ok({ error: "Artifact not found" }, 404);
+      },
+    },
+    {
+      method: "DELETE",
+      path: "/drafts/:id",
+      handler: async (req, ctx: PluginContext) => {
+        const request = asRequest(req);
+        const store = getStore(ctx);
+        store.deleteService(request.params.id);
+        return { status: 204 };
+      },
+    },
+  ];
+}

package/dist/plugins/fusion-plugin-cli-printing-press/src/run/TestRunnerPanel.css

@@ -0,0 +1,70 @@
+.clipp-test-runner {
+  display: flex;
+  flex-direction: column;
+  gap: var(--space-md);
+}
+
+.clipp-test-runner-header {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: var(--space-md);
+}
+
+.clipp-test-runner-header h4 {
+  margin: 0;
+}
+
+.clipp-test-runner-header p {
+  margin: 0;
+  color: var(--text-muted);
+}
+
+.clipp-test-runner-slug {
+  color: var(--text-muted);
+  font-weight: 400;
+}
+
+.clipp-test-runner-grid {
+  display: grid;
+  grid-template-columns: minmax(0, 1fr) minmax(0, 1fr);
+  gap: var(--space-md);
+}
+
+.clipp-test-runner-form,
+.clipp-test-runner-output {
+  display: flex;
+  flex-direction: column;
+  gap: var(--space-sm);
+}
+
+.clipp-test-runner-help {
+  color: var(--text-muted);
+  margin: 0;
+}
+
+.clipp-test-runner-status {
+  display: flex;
+  align-items: center;
+  gap: var(--space-sm);
+}
+
+.clipp-test-runner-pre {
+  margin: 0;
+  padding: var(--space-sm);
+  border-radius: var(--radius-sm);
+  font-family: var(--font-mono);
+  background: var(--surface);
+  border: var(--btn-border-width) solid var(--border);
+  white-space: pre-wrap;
+}
+
+.clipp-test-runner-pre-stderr {
+  background: color-mix(in srgb, var(--color-error) 10%, transparent);
+}
+
+@media (max-width: 768px) {
+  .clipp-test-runner-grid {
+    grid-template-columns: minmax(0, 1fr);
+  }
+}

package/dist/plugins/fusion-plugin-cli-printing-press/src/run/TestRunnerPanel.tsx

@@ -0,0 +1,98 @@
+import { AlertTriangle, CheckCircle2, Play, RefreshCw } from "lucide-react";
+import { useMemo, useState } from "react";
+import type { RunResult } from "../generation/types.js";
+import type { ServiceDraft } from "../wizard/types.js";
+import { useRunGeneratedCli } from "./useRunGeneratedCli.js";
+import "./TestRunnerPanel.css";
+
+export function CliPrintingPressTestRunner({ draftId, draft }: { draftId: string; draft: ServiceDraft }) {
+  const { regenerate, run } = useRunGeneratedCli();
+  const [selectedEndpointId, setSelectedEndpointId] = useState(draft.endpoints[0]?.id ?? "");
+  const [params, setParams] = useState<Record<string, string | number | boolean>>({});
+  const [credentials, setCredentials] = useState<Record<string, string>>({});
+  const [result, setResult] = useState<RunResult | null>(null);
+  const [generatedAt, setGeneratedAt] = useState<string | undefined>(draft.generatedAt ?? draft.regeneratedAt);
+  const [running, setRunning] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+
+  const endpoint = useMemo(() => draft.endpoints.find((item) => item.id === selectedEndpointId) ?? draft.endpoints[0], [draft.endpoints, selectedEndpointId]);
+  const paramKeys = useMemo(() => (endpoint?.params ?? "").split(",").map((item) => item.trim()).filter(Boolean), [endpoint?.params]);
+
+  async function onRegenerate() {
+    setError(null);
+    const response = await regenerate(draftId);
+    setGeneratedAt(response.artifact.generatedAt);
+  }
+
+  async function onRun() {
+    if (!endpoint) return;
+    setRunning(true);
+    setError(null);
+    setResult(null);
+    try {
+      setResult(await run(draftId, { endpointId: endpoint.id, params, credentials }));
+    } catch (err) {
+      setError(err instanceof Error ? err.message : "Run failed");
+    } finally {
+      setRunning(false);
+    }
+  }
+
+  const status = running ? "running" : (result?.timedOut || (typeof result?.exitCode === "number" && result.exitCode !== 0) ? "error" : (result ? "success" : "idle"));
+
+  return (
+    <section className="card clipp-test-runner">
+      <header className="clipp-test-runner-header">
+        <div>
+          <h4>{draft.name} <span className="clipp-test-runner-slug">({draft.slug})</span></h4>
+          <p>Generated: {generatedAt ? new Date(generatedAt).toLocaleString() : "Not generated"}</p>
+        </div>
+        <button className="btn btn-icon" onClick={() => void onRegenerate()} aria-label="Regenerate draft">
+          <RefreshCw />
+        </button>
+      </header>
+
+      <div className="clipp-test-runner-grid">
+        <div className="clipp-test-runner-form">
+          <label htmlFor={`clipp-endpoint-${draftId}`}>Endpoint</label>
+          <select id={`clipp-endpoint-${draftId}`} className="select" value={endpoint?.id ?? ""} onChange={(event) => setSelectedEndpointId(event.target.value)}>
+            {draft.endpoints.map((item) => <option key={item.id} value={item.id}>{item.method} {item.path}</option>)}
+          </select>
+
+          {paramKeys.map((key) => (
+            <div key={key} className="form-group">
+              <label htmlFor={`clipp-param-${key}`}>{key}</label>
+              <input id={`clipp-param-${key}`} className="input" value={String(params[key] ?? "")} onChange={(event) => setParams((prev) => ({ ...prev, [key]: event.target.value }))} />
+            </div>
+          ))}
+
+          <div className="clipp-test-runner-credentials">
+            <label>Credentials</label>
+            <input className="input" type="password" placeholder="api_key" value={credentials.api_key ?? ""} onChange={(event) => setCredentials((prev) => ({ ...prev, api_key: event.target.value }))} />
+            <p className="clipp-test-runner-help">Credential values are used only for this run and are not persisted.</p>
+          </div>
+
+          <button className="btn btn-primary" disabled={running} onClick={() => void onRun()}><Play /> Run</button>
+          {error ? <p className="form-error">{error}</p> : null}
+        </div>
+
+        <div className="clipp-test-runner-output">
+          <div className="clipp-test-runner-status">
+            <span className="status-dot" />
+            {status === "running" ? <><AlertTriangle /> Running…</> : null}
+            {status === "success" ? <><CheckCircle2 /> Success</> : null}
+            {status === "error" ? <><AlertTriangle /> Failed</> : null}
+            {result ? <span>{result.durationMs}ms</span> : null}
+          </div>
+          {result ? (
+            <>
+              <pre className="clipp-test-runner-pre">$ node {result.argv.join(" ")}</pre>
+              <pre className="clipp-test-runner-pre">{result.stdout || "(no stdout)"}</pre>
+              <pre className="clipp-test-runner-pre clipp-test-runner-pre-stderr">{result.stderr || "(no stderr)"}</pre>
+            </>
+          ) : <p>No run output yet.</p>}
+        </div>
+      </div>
+    </section>
+  );
+}

package/dist/plugins/fusion-plugin-cli-printing-press/src/run/useRunGeneratedCli.ts

@@ -0,0 +1,37 @@
+import type { GeneratedCliArtifact, RunRequest, RunResult } from "../generation/types.js";
+import type { ServiceDraft } from "../wizard/types.js";
+
+const BASE_PATH = "/api/plugins/cli-printing-press/drafts";
+
+async function parseJson<T>(response: Response): Promise<T> {
+  const body = await response.json().catch(() => ({}));
+  if (!response.ok) {
+    const error = (body as { error?: string }).error ?? "Request failed";
+    throw new Error(error);
+  }
+  return body as T;
+}
+
+export function useRunGeneratedCli() {
+  async function regenerate(id: string, signal?: AbortSignal): Promise<{ draft: ServiceDraft; artifact: GeneratedCliArtifact }> {
+    const response = await fetch(`${BASE_PATH}/${id}/regenerate`, { method: "POST", signal });
+    return parseJson<{ draft: ServiceDraft; artifact: GeneratedCliArtifact }>(response);
+  }
+
+  async function run(id: string, payload: RunRequest, signal?: AbortSignal): Promise<RunResult> {
+    const response = await fetch(`${BASE_PATH}/${id}/run`, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify(payload),
+      signal,
+    });
+    return parseJson<RunResult>(response);
+  }
+
+  async function getArtifact(id: string, signal?: AbortSignal): Promise<{ artifact: GeneratedCliArtifact }> {
+    const response = await fetch(`${BASE_PATH}/${id}/artifact`, { signal });
+    return parseJson<{ artifact: GeneratedCliArtifact }>(response);
+  }
+
+  return { regenerate, run, getArtifact };
+}