@johannc-dev/zyrk 0.2.0 → 0.2.2

package/README.md

@@ -1,6 +1,6 @@
 # @johannc-dev/zyrk 0.2
 
-SDK et CLI des fonctions hébergées Zyrk (runtime funrun v2, V8). Node.js 24
+SDK et CLI des fonctions hébergées Zyrk (V8). Node.js 24
 minimum. Ce package contient les types du programme, quelques aides de
 lecture, le compilateur `zyrk build`, le client HTTP et le flux d'événements.
 Le moteur, le stockage et le sandbox restent sur le serveur.
@@ -53,6 +53,13 @@ npx zyrk run wallet countBuys '{"wallet":"…","sinceMs":0,"untilMs":3600000}'
 autres API réseau dans votre code, et l'ancienne API 0.1 (`ctx.data.query`,
 `ctx.data.pages`) avec un guide de migration.
 
+Supprimer un programme : `npx zyrk delete wallet` (demande confirmation ;
+`--yes` dans un script) ou `client.delete("wallet")`. Partent ses versions,
+son état, ses abonnements, ses exécutions (celles en cours sont annulées) et
+ses replays ; `ctx.storage` reste (il appartient au compte). La place est
+libérée tout de suite et le même nom redéployé repart de zéro. Un programme
+absent répond `404 program_not_found`.
+
 Modules :
 
 | Import                        | Contenu                                               |

package/dist/cli.d.ts

@@ -1,4 +1,9 @@
 #!/usr/bin/env node
-export declare const VERSION = "0.2.0";
+export declare const VERSION = "0.2.2";
 /** `2026-11-07`, `2026-11-07T13:00:00Z` or milliseconds since the epoch. */
 export declare function timeOf(text: string): number;
+/**
+ * Whether `zyrk delete` may go on: `--yes`, or a `y` typed at the prompt.
+ * Without a terminal (a script, CI) and without `--yes` it refuses.
+ */
+export declare function confirmDeletion(name: string, yes: boolean, interactive?: boolean): Promise<boolean>;

package/dist/cli.js

@@ -5,10 +5,10 @@ import { ChildProcessSpawner } from "effect/process";
 import { BUNDLE_PATH, writeBundleEffect } from "./build.js";
 import { ZyrkClient } from "./client.js";
 import { decode, Json } from "./contracts.js";
-import { exportHistory, exportTotals, exportVolumeSearch, } from "./export.js";
+import { exportHistory, exportTotals, exportVolumeSearch, exportCompute, } from "./export.js";
 import { LocalRunner } from "./local.js";
 import { DecodeError, messageOf, } from "./errors.js";
-export const VERSION = "0.2.0";
+export const VERSION = "0.2.2";
 const print = (value) => Console.log(JSON.stringify(value, null, 2));
 const entry = Argument.String("entry.ts").pipe(Argument.withDescription("TypeScript or JavaScript entry point of the program"));
 const program = Argument.String("program").pipe(Argument.withDescription("Program name"));
@@ -47,6 +47,26 @@ export function timeOf(text) {
         throw new Error(`Not a date: ${text}`);
     return ms;
 }
+export async function confirmDeletion(name, yes, interactive = process.stdin.isTTY === true) {
+    if (yes)
+        return true;
+    if (!interactive) {
+        process.stderr.write(`error[NotConfirmed]: zyrk delete ${name} deletes the program, its state, subscriptions, executions and replays: add --yes to confirm without a terminal\n`);
+        return false;
+    }
+    const { createInterface } = await import("node:readline/promises");
+    const prompt = createInterface({
+        input: process.stdin,
+        output: process.stderr,
+    });
+    try {
+        const answer = await prompt.question(`Delete program ${name} with its state, subscriptions, executions and replays (ctx.storage stays)? [y/N] `);
+        return /^y(es)?$/i.test(answer.trim());
+    }
+    finally {
+        prompt.close();
+    }
+}
 const local = (name, body) => Effect.promise(() => body().catch((error) => {
     process.stderr.write(`error[${name}]: ${error instanceof Error ? error.message : String(error)}\n`);
     process.exitCode = 1;
@@ -65,11 +85,12 @@ const exportCommand = Command.make("export", {
     "with-events": flag("with-events", "Export pool events too (implies --with-market)"),
     "with-order": flag("with-order", "Export batch.order (on-chain order)"),
     "with-tx": flag("with-tx", "Export batch.tx (transaction of each trade, place in it)"),
-    refresh: flag("refresh", "Download every hour again (a finished export only re-downloads the hours that were open or not sealed)"),
-    totals: optionalString("totals", "Also save /v1/tokens/{mint}/totals of this mint"),
-    quote: optionalString("quote", "Quote mint of --totals"),
+    refresh: flag("refresh", "Download every hour again (a finished export only re-downloads the hours that were open or not sealed, or exported by an older version)"),
+    totals: optionalString("totals", "Also save the totals of this mint (ctx.data.tokenTotals, tokenInfo)"),
+    quote: optionalString("quote", "Quote mint of --totals, or auto"),
+    compute: optionalString("compute", "Also save the answer of ctx.compute(<json plan or array of plans>), computed by the service"),
     "volume-search": optionalString("volume-search", "Also save every page of ctx.data.volumeSearch(<json params>)"),
-    rpm: Flag.Int("rpm").pipe(Flag.withDescription("At most this many requests per minute"), Flag.optional),
+    rpm: Flag.Int("rpm").pipe(Flag.withDescription("At most this many requests per minute (optional: the server allows 30 a second per account)"), Flag.optional),
     out: Flag.String("out").pipe(Flag.withAlias("o"), Flag.withDescription("Data directory (created, resumed if it exists)"), Flag.withDefault("data")),
 }, (input) => local("export", async () => {
     const url = process.env.TH_API_URL;
@@ -119,6 +140,12 @@ const exportCommand = Command.make("export", {
         await exportTotals(connection, input.out, totals, value(input.quote) ?? null);
         work = true;
     }
+    const computeText = value(input.compute);
+    if (computeText) {
+        const r = await exportCompute(connection, input.out, JSON.parse(computeText));
+        process.stderr.write(`compute: ${r.rows === null ? "an error answer (saved: the local run throws it)" : `${r.rows} row(s)`}\n`);
+        work = true;
+    }
     const volume = value(input["volume-search"]);
     if (volume) {
         const pages = await exportVolumeSearch(connection, input.out, JSON.parse(volume));
@@ -126,7 +153,7 @@ const exportCommand = Command.make("export", {
         work = true;
     }
     if (!work)
-        throw new Error("Nothing to export: --token/--wallet, --totals or --volume-search");
+        throw new Error("Nothing to export: --token/--wallet, --totals, --volume-search or --compute");
 })).pipe(Command.withDescription("Download history (one file per hour, as hosted programs see it) for zyrk dev. Resumes an interrupted export."));
 const devCommand = Command.make("dev", {
     entry,
@@ -139,7 +166,7 @@ const devCommand = Command.make("dev", {
     replay: optionalString("replay", "Replay this subscription over --since/--until: <function> is ignored, json is unused"),
     since: optionalString("since", "Replay start"),
     until: optionalString("until", "Replay end"),
-    "events-per-delivery": Flag.Int("events-per-delivery").pipe(Flag.withDescription("Events per replayed delivery (1 to 32, default 1)"), Flag.optional),
+    "events-per-delivery": Flag.Int("events-per-delivery").pipe(Flag.withDescription("Events per replayed delivery (1 to 32, default 32; interval triggers: 1)"), Flag.optional),
     quiet: flag("quiet", "Do not print logs and emits as they happen"),
     "no-typecheck": noTypecheck,
 }, (input) => local("dev", async () => {
@@ -248,6 +275,15 @@ const zyrk = Command.make("zyrk").pipe(Command.withDescription("Zyrk hosted func
     Command.make("programs", {}, () => withClient((c) => c.programs())).pipe(Command.withDescription("List the programs of the account")),
     onArgument("inspect", "Show a program", program, (c, p) => c.inspect(p)),
     onArgument("executions", "Recent executions of a program", program, (c, p) => c.executions(p)),
+    Command.make("delete", {
+        program,
+        yes: flag("yes", "Do not ask for confirmation"),
+    }, (input) => Effect.promise(() => confirmDeletion(input.program, input.yes)).pipe(Effect.flatMap((confirmed) => {
+        if (confirmed)
+            return withClient((c) => c.delete(input.program));
+        process.exitCode = 1;
+        return Effect.void;
+    }))).pipe(Command.withDescription("Delete a program and everything bound to it (state, subscriptions, executions, replays); ctx.storage stays. Asks first unless --yes")),
     onArgument("pause", "Pause a program", program, (c, p) => c.pause(p, true)),
     onArgument("resume", "Resume a program", program, (c, p) => c.pause(p, false)),
     exportCommand,

package/dist/client.d.ts

@@ -1,8 +1,8 @@
 import { Context, Effect, Layer } from "effect";
-import { Job, Json, ProgramSummary, type JobResult } from "./contracts.js";
+import { Job, Json, ProgramDeleted, ProgramSummary, type JobResult } from "./contracts.js";
 import { ApiError, ConfigError, DecodeError, ExecutionEnded, ExecutionFailed, NetworkError, WaitTimeout } from "./errors.js";
 export * from "./errors.js";
-export type { Job, JobResult, ProgramSummary } from "./contracts.js";
+export type { Job, JobResult, ProgramDeleted, ProgramSummary, } from "./contracts.js";
 import type { ReplayFeedItem, ReplayRecord, ReplayRequest } from "./sdk.js";
 export type { ReplayFeedItem, ReplayRecord, ReplayRequest } from "./sdk.js";
 export interface ClientConfig {
@@ -18,7 +18,11 @@ export interface StartInput {
     readonly requestId?: string;
 }
 export interface WaitOptions {
-    /** Delay between two status checks, in milliseconds (default 1000). */
+    /**
+     * Delay between two status checks, in milliseconds. Without it, each check
+     * is held by the service until the execution ends (at most 10 s), and a
+     * service that cannot hold is checked once a second.
+     */
     readonly pollMs?: number;
     /** Give up after this many milliseconds (default: never). The execution keeps running. */
     readonly timeoutMs?: number;
@@ -42,6 +46,13 @@ export interface ZyrkClientService {
     programs(): Effect.Effect<readonly ProgramSummary[], RequestError>;
     inspect(program: string): Effect.Effect<Json, RequestError>;
     pause(program: string, paused?: boolean): Effect.Effect<Json, RequestError>;
+    /**
+     * Deletes the program and everything bound to it (versions, state,
+     * subscriptions, executions, replays); what runs of it is cancelled.
+     * The account's storage stays. Fails with `program_not_found` (404) when
+     * there is no such program, also when a retried call already deleted it.
+     */
+    delete(program: string): Effect.Effect<ProgramDeleted, RequestError>;
     /** Recent executions of a program (summaries). */
     executions(program: string): Effect.Effect<Json, RequestError>;
     /** Starts an execution and returns its id. */
@@ -121,6 +132,8 @@ export declare class FunctionsClient {
     programs(signal?: AbortSignal): Promise<readonly ProgramSummary[]>;
     inspect(program: string, signal?: AbortSignal): Promise<Json>;
     pause(program: string, paused?: boolean, signal?: AbortSignal): Promise<Json>;
+    /** See {@link ZyrkClientService.delete}. */
+    delete(program: string, signal?: AbortSignal): Promise<ProgramDeleted>;
     executions(program: string, signal?: AbortSignal): Promise<Json>;
     start(program: string, input: StartInput, signal?: AbortSignal): Promise<string>;
     execution(id: string, signal?: AbortSignal): Promise<Job>;
@@ -154,7 +167,7 @@ export declare class FunctionsClient {
      */
     replayEmits(id: string, afterSeq?: number, signal?: AbortSignal): Promise<ReplayFeedItem[]>;
 }
-/** Lakebed's `StorageObjectHead` as the HTTP headers describe it. */
+/** The head of a stored object as the HTTP headers describe it. */
 export interface HttpStorageHead {
     readonly key: string;
     readonly size: number;