@manyoars/oars 0.2.0 → 0.4.0

package/dist/commands/deploy-input.d.ts

@@ -1,38 +0,0 @@
-import type { components } from '@manyoars/oars-client';
-import type { AgentTemplate } from './templates.js';
-type RegisterWorkloadRequest = components['schemas']['RegisterWorkloadRequest'];
-type CreatePriceInput = components['schemas']['CreatePriceInput'];
-/** What `oars deploy` is told to deploy, as the flags give it. A flag the developer did not pass is undefined. */
-export interface DeployFlags {
-    template?: string;
-    image?: string;
-    manifestFile?: string;
-    name?: string;
-    port?: number;
-    public?: boolean;
-    cpuMillicores?: number;
-    memoryMib?: number;
-    alwaysOn?: boolean;
-    /** `--price`: starter prices to pick from a template (all of them by default). */
-    prices: string[];
-    /** `--no-prices`. */
-    noPrices: boolean;
-    priceFile?: string;
-    /** `NAME=value` entries. */
-    secrets: string[];
-    /** Names of environment variables to read. */
-    secretsFromEnv: string[];
-}
-/** The register body and the prices to create, validated and ready to send. */
-export interface DeployInput {
-    request: RegisterWorkloadRequest;
-    prices: CreatePriceInput[];
-}
-/** Reads the catalog once, when a `--template` deploy has passed every check that needs no network. */
-export type TemplateLookup = () => Promise<AgentTemplate[]>;
-/**
- * Turns the flags into the calls' bodies. Exactly one of `--template`, `--image`, `--manifest`. Every mistake the flags alone can
- * show is found before any request; only `--template` then reads the catalog (`catalog`), so a typo there costs one GET.
- */
-export declare const loadDeployInput: (flags: DeployFlags, env: NodeJS.ProcessEnv, catalog: TemplateLookup) => Promise<DeployInput>;
-export {};

package/dist/commands/deploy-input.js

@@ -1,150 +0,0 @@
-import { readFile } from 'node:fs/promises';
-import { CliError, ExitCode } from '../errors.js';
-const usage = (message) => new CliError(message, ExitCode.USAGE, 'usage');
-const DIGEST = /@sha256:[0-9a-f]{64}$/;
-const PRICE_KINDS = ['ONE_TIME', 'RECURRING_MONTHLY', 'CREDIT_PACK'];
-const isObject = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
-const has = (value, key, type) => typeof Reflect.get(value, key) === type;
-const isService = (value) => isObject(value) && has(value, 'name', 'string') && has(value, 'image', 'string') && has(value, 'cpuMillicores', 'number') && has(value, 'memoryMib', 'number');
-const isRegisterRequest = (value) => {
-    if (!isObject(value) || !has(value, 'name', 'string'))
-        return false;
-    const services = Reflect.get(value, 'services');
-    return Array.isArray(services) && services.length > 0 && services.every(isService);
-};
-const isPriceKind = (value) => PRICE_KINDS.some((kind) => kind === value);
-const isPrice = (value) => isObject(value) && has(value, 'priceRef', 'string') && has(value, 'displayName', 'string') && has(value, 'amountUsd', 'string') && isPriceKind(Reflect.get(value, 'kind'));
-const isPrices = (value) => Array.isArray(value) && value.every(isPrice);
-/** A JSON file's parsed content; a file that cannot be read or parsed is exit 2 naming it. */
-const readJson = async (path) => {
-    let text;
-    try {
-        text = await readFile(path, 'utf8');
-    }
-    catch (error) {
-        throw usage(`Cannot read ${path}: ${error instanceof Error ? error.message : String(error)}`);
-    }
-    try {
-        return JSON.parse(text);
-    }
-    catch (error) {
-        throw usage(`${path} is not valid JSON: ${error instanceof Error ? error.message : String(error)}`);
-    }
-};
-/** The platform deploys what a digest names; a tag can move, so a service without one is refused before any request. */
-const requireDigest = (image) => {
-    if (!DIGEST.test(image)) {
-        throw usage(`${image} is not pinned by digest. Print one with: docker buildx imagetools inspect ${image}\nthen deploy <name>@sha256:<64 hex digits>.`);
-    }
-};
-const secretsFrom = (flags, env) => [
-    ...flags.secrets.map((entry) => {
-        const at = entry.indexOf('=');
-        // The entry may be the secret itself, so the message does not echo it.
-        if (at < 1)
-            throw usage('--secret takes NAME=value; use --secret-from-env NAME to read the value from the environment.');
-        return { name: entry.slice(0, at), value: entry.slice(at + 1) };
-    }),
-    ...flags.secretsFromEnv.map((name) => {
-        const value = env[name];
-        if (value === undefined || value === '')
-            throw usage(`--secret-from-env ${name}: the environment variable ${name} is not set.`);
-        return { name, value };
-    }),
-];
-const requestFromFlags = (flags, image) => {
-    if (flags.name === undefined)
-        throw usage('--image needs --name <name>.');
-    requireDigest(image);
-    return {
-        name: flags.name,
-        ...(flags.alwaysOn === true ? { alwaysOn: true } : {}),
-        services: [{ name: 'app', image, port: flags.port ?? 8080, public: flags.public ?? false, cpuMillicores: flags.cpuMillicores ?? 250, memoryMib: flags.memoryMib ?? 256 }],
-    };
-};
-/** The register body of an --image or --manifest deploy. */
-const imageOrFileRequest = async (flags) => {
-    if (flags.image !== undefined)
-        return requestFromFlags(flags, flags.image);
-    if (flags.manifestFile !== undefined)
-        return requestFromFile(flags, flags.manifestFile);
-    throw usage('Pass exactly one of --template, --image, or --manifest.');
-};
-/** The flags that describe an --image deploy; a template or a manifest file holds its own. */
-const refuseImageFlags = (flags, source) => {
-    const given = ['name', 'port', 'public', 'cpuMillicores', 'memoryMib'].filter((key) => flags[key] !== undefined);
-    if (given.length > 0)
-        throw usage(`--name, --port, --public, --cpu-millicores, and --memory-mib describe an --image deploy; ${source} holds its own.`);
-};
-const requestFromFile = async (flags, path) => {
-    refuseImageFlags(flags, 'a --manifest file');
-    const parsed = await readJson(path);
-    if (!isRegisterRequest(parsed)) {
-        throw usage(`${path} is not a workload manifest: it needs a name and services, each with name, image, cpuMillicores and memoryMib.`);
-    }
-    for (const service of parsed.services)
-        requireDigest(service.image);
-    return flags.alwaysOn === true ? { ...parsed, alwaysOn: true } : parsed;
-};
-const pricesFromFile = async (path) => {
-    const parsed = await readJson(path);
-    if (!isPrices(parsed)) {
-        throw usage(`${path} must be a JSON array of prices, each with priceRef, displayName, amountUsd (a decimal string) and kind (ONE_TIME, RECURRING_MONTHLY or CREDIT_PACK).`);
-    }
-    return parsed;
-};
-/** A starter price as the create call takes it. `credits` is left out of a price that has none (the wire may carry null). */
-const priceFromTemplate = (price) => ({
-    priceRef: price.priceRef,
-    displayName: price.displayName,
-    amountUsd: price.amountUsd,
-    kind: price.kind,
-    ...(typeof price.credits === 'number' ? { credits: price.credits } : {}),
-});
-/** `--template`: the entry's manifest, and the starter prices `--price` picked (every one without it, none for `--no-prices`). */
-const fromTemplate = (flags, template) => {
-    const wanted = flags.noPrices ? [] : flags.prices;
-    const unknown = wanted.filter((ref) => !template.starterPrices.some((price) => price.priceRef === ref));
-    if (unknown.length > 0) {
-        throw usage(`Template ${template.templateId} has no starter price ${unknown.join(', ')}; its prices are ${template.starterPrices.map((price) => price.priceRef).join(', ')}.`);
-    }
-    const chosen = flags.noPrices || flags.prices.length > 0 ? template.starterPrices.filter((price) => wanted.includes(price.priceRef)) : template.starterPrices;
-    return { request: flags.alwaysOn === true ? { ...template.manifest, alwaysOn: true } : template.manifest, prices: chosen.map(priceFromTemplate) };
-};
-/** A catalog entry's id is what the platform serves, so an id it does not list is exit 2 naming the ids it does. */
-const findTemplate = async (id, resolve) => {
-    const catalog = await resolve();
-    const found = catalog.find((template) => template.templateId === id);
-    if (found === undefined) {
-        throw usage(`No template ${id}. ${catalog.length === 0 ? 'The catalog is empty.' : `Available: ${catalog.map((template) => template.templateId).join(', ')}.`} List them with: oars templates`);
-    }
-    return found;
-};
-/** The checks on a `--template` deploy's flags, then its catalog entry; the flags are all read before the one GET. */
-const templateInput = async (flags, id, catalog) => {
-    refuseImageFlags(flags, 'the template');
-    if (flags.priceFile !== undefined)
-        throw usage('--price-file adds prices to an --image or --manifest deploy; a template brings its own: choose among them with --price, or skip them with --no-prices.');
-    if (flags.noPrices && flags.prices.length > 0)
-        throw usage('--price and --no-prices contradict each other.');
-    return fromTemplate(flags, await findTemplate(id, catalog));
-};
-/**
- * Turns the flags into the calls' bodies. Exactly one of `--template`, `--image`, `--manifest`. Every mistake the flags alone can
- * show is found before any request; only `--template` then reads the catalog (`catalog`), so a typo there costs one GET.
- */
-export const loadDeployInput = async (flags, env, catalog) => {
-    if ([flags.template, flags.image, flags.manifestFile].filter((source) => source !== undefined).length !== 1) {
-        throw usage('Pass exactly one of --template, --image, or --manifest.');
-    }
-    const picked = flags.template === undefined ? undefined : await templateInput(flags, flags.template, catalog);
-    if (picked === undefined && (flags.prices.length > 0 || flags.noPrices)) {
-        throw usage("--price and --no-prices choose among a template's starter prices; use --price-file with --image or --manifest.");
-    }
-    const base = picked?.request ?? (await imageOrFileRequest(flags));
-    const secrets = [...(base.secrets ?? []), ...secretsFrom(flags, env)];
-    return {
-        request: secrets.length === 0 ? base : { ...base, secrets },
-        prices: picked?.prices ?? (flags.priceFile === undefined ? [] : await pricesFromFile(flags.priceFile)),
-    };
-};

package/dist/commands/deploy.d.ts

@@ -1,22 +0,0 @@
-import { type DeployFlags } from './deploy-input.js';
-import type { Outcome, RunDeps } from '../cli.js';
-export interface DeployOptions extends DeployFlags {
-    apiUrl: string;
-    /** The command line as typed (without the node and script entries), for the rerun line. */
-    argv: string[];
-    /** False for `--no-start`: register and price, but make no deploy call. */
-    start: boolean;
-    /** `--idempotency-key`: the base of every step's key. A fresh UUID when absent. */
-    idempotencyKey?: string;
-}
-/**
- * The command that resumes a failed deploy: the same arguments plus `--idempotency-key <base>`. Secret values are never
- * printed, so `--secret NAME=value` becomes `--secret-from-env NAME` (the developer exports NAME before the rerun).
- */
-export declare const rerunCommand: (argv: string[], base: string) => string;
-/**
- * The web deploy page's order: register, each price, deploy (design §3.1). Each call carries its own idempotency key
- * (`stepKey(base, step)`), so a rerun with the same base replays what finished and carries on. The first failed step stops
- * the sequence (exit 9) with the workload id, the rerun line, and the SDK key when this run minted it.
- */
-export declare const deploy: (deps: RunDeps, options: DeployOptions) => Promise<Outcome>;

package/dist/commands/deploy.js

@@ -1,124 +0,0 @@
-import { randomUUID } from 'node:crypto';
-import { apiClient, unwrap } from '../api.js';
-import { CliError, ExitCode } from '../errors.js';
-import { stepKey } from '../journal.js';
-import { resolveAuthToken } from '../session.js';
-import { loadDeployInput } from './deploy-input.js';
-import { listTemplates, STEP as TEMPLATES_STEP } from './templates.js';
-const SHELL_SAFE = /^[A-Za-z0-9_@%+=:,./-]+$/;
-const quote = (token) => (SHELL_SAFE.test(token) ? token : `'${token.replaceAll("'", "'\\''")}'`);
-/**
- * The command that resumes a failed deploy: the same arguments plus `--idempotency-key <base>`. Secret values are never
- * printed, so `--secret NAME=value` becomes `--secret-from-env NAME` (the developer exports NAME before the rerun).
- */
-export const rerunCommand = (argv, base) => {
-    const secretName = (entry) => entry.split('=')[0] ?? '';
-    const tokens = [];
-    for (let at = 0; at < argv.length; at += 1) {
-        const arg = argv[at] ?? '';
-        if (arg === '--idempotency-key') {
-            at += 1;
-        }
-        else if (arg === '--secret') {
-            at += 1;
-            tokens.push('--secret-from-env', secretName(argv[at] ?? ''));
-        }
-        else if (arg.startsWith('--secret=')) {
-            tokens.push('--secret-from-env', secretName(arg.slice('--secret='.length)));
-        }
-        else if (!arg.startsWith('--idempotency-key=')) {
-            tokens.push(arg);
-        }
-    }
-    return ['oars', ...tokens, '--idempotency-key', base].map(quote).join(' ');
-};
-/** A failure after register is exit 9 whatever its own code: the workload exists, so the developer's next move is the rerun. */
-const partialFailure = (error, step, partial) => {
-    const cause = error instanceof CliError ? error : new CliError(`Unexpected error: ${error instanceof Error ? error.message : String(error)}`, ExitCode.UNEXPECTED, step);
-    return new CliError(cause.message, ExitCode.PARTIAL, step, cause.problem, partial);
-};
-/**
- * The web deploy page's order: register, each price, deploy (design §3.1). Each call carries its own idempotency key
- * (`stepKey(base, step)`), so a rerun with the same base replays what finished and carries on. The first failed step stops
- * the sequence (exit 9) with the workload id, the rerun line, and the SDK key when this run minted it.
- */
-export const deploy = async (deps, options) => {
-    // Resolved once, and only when a step needs it: a deploy with a mistake in its flags fails before it asks for a login.
-    let pending;
-    const authToken = () => (pending ??= resolveAuthToken(deps, options.apiUrl));
-    const input = await loadDeployInput(options, deps.env, async () => listTemplates(apiClient(deps, { apiUrl: options.apiUrl, step: TEMPLATES_STEP, token: await authToken() })));
-    const token = await authToken();
-    const base = options.idempotencyKey ?? randomUUID();
-    const clientFor = (step) => apiClient(deps, { apiUrl: options.apiUrl, step, token });
-    const prior = await deps.journal.read(base).catch(() => undefined);
-    const progress = { base, steps: prior?.steps ?? [] };
-    if (prior !== undefined) {
-        deps.io.stderr(`Resuming deploy ${base}: ${prior.steps.map((entry) => entry.step).join(', ') || 'nothing finished yet'} already done.\n`);
-    }
-    // The journal only tells the developer where the last run got to; the platform's replay is what makes the rerun correct, so
-    // a journal that cannot be written must not lose the one-time SDK key.
-    const note = async (step, status) => {
-        progress.steps = [...progress.steps.filter((entry) => entry.step !== step), { step, status }];
-        await deps.journal.write(progress).catch((error) => {
-            deps.io.stderr(`Could not record progress in the journal: ${error instanceof Error ? error.message : String(error)}\n`);
-        });
-    };
-    const registerResult = await clientFor('register').POST('/agents/workloads', {
-        params: { header: { 'Idempotency-Key': stepKey(base, 'register') } },
-        body: input.request,
-    });
-    const workload = unwrap('register', registerResult);
-    await note('register', registerResult.response.status);
-    // A replayed registration carries no key: only the run that created the workload can show it.
-    const partial = { workloadId: workload.id, ...(workload.sdkKey === undefined ? {} : { sdkKey: workload.sdkKey }), rerun: rerunCommand(options.argv, base) };
-    const path = { workloadId: workload.id };
-    const stages = [
-        ...input.prices.map((price) => {
-            const step = `price:${price.priceRef}`;
-            return {
-                step,
-                send: async () => {
-                    const result = await clientFor(step).POST('/billing/agents/{workloadId}/prices', { params: { path }, headers: { 'Idempotency-Key': stepKey(base, step) }, body: price });
-                    unwrap(step, result);
-                    return result.response.status;
-                },
-            };
-        }),
-        ...(options.start
-            ? [
-                {
-                    step: 'deploy',
-                    send: async () => {
-                        const result = await clientFor('deploy').POST('/agents/workloads/{workloadId}/deploy', { params: { path }, headers: { 'Idempotency-Key': stepKey(base, 'deploy') } });
-                        unwrap('deploy', result);
-                        return result.response.status;
-                    },
-                },
-            ]
-            : []),
-    ];
-    for (const stage of stages) {
-        let status;
-        try {
-            status = await stage.send();
-        }
-        catch (error) {
-            throw partialFailure(error, stage.step, partial);
-        }
-        await note(stage.step, status);
-    }
-    await deps.journal.delete(base).catch(() => undefined);
-    const prices = input.prices.map((price) => price.priceRef);
-    const nextSteps = [`oars status ${workload.id}`, `oars test-charge ${workload.id}${prices[0] === undefined ? '' : ` --price ${prices[0]}`}`];
-    const lines = [
-        `${options.start ? 'Deployed' : 'Registered'} ${workload.name} (workload ${workload.id})`,
-        ...(workload.sdkKey === undefined ? [] : [`SDK key (shown once; save it now): ${workload.sdkKey}`]),
-        ...(prices.length === 0 ? [] : [`Prices: ${prices.join(', ')}`]),
-        'Next:',
-        ...nextSteps.map((step) => `  ${step}`),
-    ];
-    return {
-        document: { ok: true, workloadId: workload.id, ...(workload.sdkKey === undefined ? {} : { sdkKey: workload.sdkKey }), prices, started: options.start, nextSteps },
-        text: lines.join('\n'),
-    };
-};

package/dist/commands/status.d.ts

@@ -1,7 +0,0 @@
-import type { Outcome, RunDeps } from '../cli.js';
-export interface StatusOptions {
-    apiUrl: string;
-    workloadId: string;
-}
-/** The workload (`GET /agents/workloads/{id}`) and its billing mode (`GET /billing/agents/{id}/mode`, TEST until the creator goes live). */
-export declare const status: (deps: RunDeps, options: StatusOptions) => Promise<Outcome>;

package/dist/commands/status.js

@@ -1,18 +0,0 @@
-import { apiClient, unwrap } from '../api.js';
-import { resolveAuthToken } from '../session.js';
-const STEP = 'status';
-/** The workload (`GET /agents/workloads/{id}`) and its billing mode (`GET /billing/agents/{id}/mode`, TEST until the creator goes live). */
-export const status = async (deps, options) => {
-    const client = apiClient(deps, { apiUrl: options.apiUrl, step: STEP, token: await resolveAuthToken(deps, options.apiUrl) });
-    const params = { path: { workloadId: options.workloadId } };
-    const workload = unwrap(STEP, await client.GET('/agents/workloads/{workloadId}', { params }));
-    const { billingMode } = unwrap(STEP, await client.GET('/billing/agents/{workloadId}/mode', { params }));
-    const { deployment } = workload;
-    const lines = [
-        `${workload.name} (${workload.id})`,
-        `Workload: ${workload.status}${workload.suspended ? ' (suspended)' : ''}`,
-        `Deployment: ${deployment.status} (${deployment.health}), desired ${deployment.desiredState}`,
-        `Billing mode: ${billingMode}`,
-    ];
-    return { document: { ok: true, workload, billingMode }, text: lines.join('\n') };
-};

package/dist/commands/templates.d.ts

@@ -1,11 +0,0 @@
-import type { components, OarsClient } from '@manyoars/oars-client';
-import type { Outcome, RunDeps } from '../cli.js';
-export type AgentTemplate = components['schemas']['AgentTemplateResponse'];
-export interface TemplatesOptions {
-    apiUrl: string;
-}
-export declare const STEP = "templates";
-/** Every entry of `GET /agents/templates`, following the pages until the last one. */
-export declare const listTemplates: (client: OarsClient) => Promise<AgentTemplate[]>;
-/** `oars templates`: the platform's starter-template catalog, the ids `oars deploy --template` takes. */
-export declare const templates: (deps: RunDeps, options: TemplatesOptions) => Promise<Outcome>;

package/dist/commands/templates.js

@@ -1,32 +0,0 @@
-import { apiClient, unwrap } from '../api.js';
-import { resolveAuthToken } from '../session.js';
-export const STEP = 'templates';
-// The catalog holds a handful of entries; a page this large is the whole of it, and the loop below only covers a catalog that outgrows it.
-const PAGE_SIZE = 100;
-/** Every entry of `GET /agents/templates`, following the pages until the last one. */
-export const listTemplates = async (client) => {
-    const templates = [];
-    for (let page = 0;; page += 1) {
-        const result = unwrap(STEP, await client.GET('/agents/templates', { params: { query: { page, size: PAGE_SIZE } } }));
-        templates.push(...result.content);
-        if (result.last)
-            return templates;
-    }
-};
-const describePrice = (price) => `${price.priceRef} ($${price.amountUsd}${typeof price.credits === 'number' ? `, ${String(price.credits)} credits` : ''})`;
-/** `oars templates`: the platform's starter-template catalog, the ids `oars deploy --template` takes. */
-export const templates = async (deps, options) => {
-    const client = apiClient(deps, { apiUrl: options.apiUrl, step: STEP, token: await resolveAuthToken(deps, options.apiUrl) });
-    const catalog = await listTemplates(client);
-    const lines = catalog.length === 0
-        ? ['No starter templates are available.']
-        : [
-            ...catalog.flatMap((template) => [
-                `${template.templateId}: ${template.name}`,
-                `  ${template.description}`,
-                ...(template.starterPrices.length === 0 ? [] : [`  Prices: ${template.starterPrices.map(describePrice).join(', ')}`]),
-            ]),
-            'Deploy one with: oars deploy --template <id>',
-        ];
-    return { document: { ok: true, templates: catalog }, text: lines.join('\n') };
-};

package/dist/commands/test-charge.d.ts

@@ -1,11 +0,0 @@
-import type { Outcome, RunDeps } from '../cli.js';
-export interface TestChargeOptions {
-    apiUrl: string;
-    workloadId: string;
-    /** `--price`; absent means the workload's one active price. */
-    priceRef?: string;
-    /** The base of the step key, so a retry of this command replays the charge instead of making a second one. */
-    idempotencyKey: string;
-}
-/** `POST /billing/agents/{id}/test-charges`: a TEST-mode charge against one of the workload's prices (no money moves). */
-export declare const testCharge: (deps: RunDeps, options: TestChargeOptions) => Promise<Outcome>;

package/dist/commands/test-charge.js

@@ -1,34 +0,0 @@
-import { apiClient, unwrap } from '../api.js';
-import { CliError, ExitCode } from '../errors.js';
-import { stepKey } from '../journal.js';
-import { resolveAuthToken } from '../session.js';
-const STEP = 'test-charge';
-/** The price a charge without `--price` uses: the workload's only active one, else exit 2 saying which to pick from. */
-const onlyActivePrice = async (client, workloadId) => {
-    const page = unwrap(STEP, await client.GET('/billing/agents/{workloadId}/prices', { params: { path: { workloadId }, query: { size: 100 } } }));
-    const active = page.content.filter((price) => price.active).map((price) => price.priceRef);
-    if (!page.last) {
-        throw new CliError(`${workloadId} has more prices than one request lists; pass --price <priceRef>.`, ExitCode.USAGE, 'usage');
-    }
-    const [only, ...others] = active;
-    if (only === undefined) {
-        throw new CliError(`${workloadId} has no active price; create one, or pass --price <priceRef>.`, ExitCode.USAGE, 'usage');
-    }
-    if (others.length > 0) {
-        throw new CliError(`${workloadId} has several active prices (${active.join(', ')}); pass --price <priceRef>.`, ExitCode.USAGE, 'usage');
-    }
-    return only;
-};
-/** `POST /billing/agents/{id}/test-charges`: a TEST-mode charge against one of the workload's prices (no money moves). */
-export const testCharge = async (deps, options) => {
-    const client = apiClient(deps, { apiUrl: options.apiUrl, step: STEP, token: await resolveAuthToken(deps, options.apiUrl) });
-    const priceRef = options.priceRef ?? (await onlyActivePrice(client, options.workloadId));
-    const charge = unwrap(STEP, await client.POST('/billing/agents/{workloadId}/test-charges', {
-        params: { path: { workloadId: options.workloadId }, header: { 'Idempotency-Key': stepKey(options.idempotencyKey, STEP) } },
-        body: { priceRef },
-    }));
-    return {
-        document: { ok: true, chargeId: charge.chargeId, status: charge.status },
-        text: `Test charge ${charge.chargeId} for ${priceRef}: ${charge.status}`,
-    };
-};

package/dist/journal.d.ts

@@ -1,26 +0,0 @@
-/**
- * Where a command got to, for the rerun that follows a failure (design §3.2). It holds step names and the HTTP status each
- * answered with, never a secret: the SDK key is shown once and the platform replays every finished step by its idempotency key.
- */
-export interface JournalRecord {
-    /** The human base key (`--idempotency-key` or the UUID the first run made). */
-    base: string;
-    steps: Array<{
-        step: string;
-        status: number;
-    }>;
-}
-export interface JournalStore {
-    /** Undefined when no run with this base key has left a record, including when the file is unreadable as one. */
-    read: (base: string) => Promise<JournalRecord | undefined>;
-    write: (record: JournalRecord) => Promise<void>;
-    delete: (base: string) => Promise<void>;
-}
-/** One step's `Idempotency-Key`: the lowercase SHA-256 hex of `<base>:<step>`, the 64-hex form every aor-common interceptor accepts. */
-export declare const stepKey: (base: string, step: string) => string;
-/**
- * Keeps one file per base key in `<dir>/oars/journal/`, named by the key's hash because the key is whatever the developer typed.
- * A write goes to a sibling file and is renamed over the old one; a torn file reads as no record, and the platform's replay
- * makes the rerun correct either way.
- */
-export declare const fileJournalStore: (dir: string) => JournalStore;

package/dist/journal.js

@@ -1,58 +0,0 @@
-import { createHash } from 'node:crypto';
-import { mkdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
-import { join } from 'node:path';
-/** One step's `Idempotency-Key`: the lowercase SHA-256 hex of `<base>:<step>`, the 64-hex form every aor-common interceptor accepts. */
-export const stepKey = (base, step) => createHash('sha256').update(`${base}:${step}`).digest('hex');
-const isRecord = (value) => {
-    if (typeof value !== 'object' || value === null)
-        return false;
-    const base = Reflect.get(value, 'base');
-    const steps = Reflect.get(value, 'steps');
-    return (typeof base === 'string' &&
-        Array.isArray(steps) &&
-        steps.every((entry) => typeof entry === 'object' && entry !== null && typeof Reflect.get(entry, 'step') === 'string' && typeof Reflect.get(entry, 'status') === 'number'));
-};
-const isMissing = (error) => error instanceof Error && 'code' in error && error.code === 'ENOENT';
-/**
- * Keeps one file per base key in `<dir>/oars/journal/`, named by the key's hash because the key is whatever the developer typed.
- * A write goes to a sibling file and is renamed over the old one; a torn file reads as no record, and the platform's replay
- * makes the rerun correct either way.
- */
-export const fileJournalStore = (dir) => {
-    const folder = join(dir, 'oars', 'journal');
-    const fileFor = (base) => join(folder, `${createHash('sha256').update(base).digest('hex')}.json`);
-    return {
-        read: async (base) => {
-            let text;
-            try {
-                text = await readFile(fileFor(base), 'utf8');
-            }
-            catch (error) {
-                if (isMissing(error))
-                    return undefined;
-                throw error;
-            }
-            try {
-                const parsed = JSON.parse(text);
-                return isRecord(parsed) && parsed.base === base ? parsed : undefined;
-            }
-            catch {
-                return undefined;
-            }
-        },
-        write: async (record) => {
-            await mkdir(folder, { recursive: true, mode: 0o700 });
-            const file = fileFor(record.base);
-            const temp = `${file}.tmp`;
-            try {
-                await writeFile(temp, `${JSON.stringify(record, null, 2)}\n`, { mode: 0o600 });
-                await rename(temp, file);
-            }
-            catch (error) {
-                await rm(temp, { force: true });
-                throw error;
-            }
-        },
-        delete: (base) => rm(fileFor(base), { force: true }),
-    };
-};

package/parity/deploy-plans/paid-api.json

@@ -1,34 +0,0 @@
-[
-  {
-    "method": "POST",
-    "path": "/agents/workloads",
-    "body": {
-      "name": "Paid API",
-      "services": [
-        {
-          "name": "api",
-          "image": "ghcr.io/manyoars/paid-api@sha256:c24de301f3b29f912c6235046b1f964a213b8437e496ba4b9f9de362e094b13f",
-          "port": 8080,
-          "public": true,
-          "cpuMillicores": 250,
-          "memoryMib": 256
-        }
-      ]
-    }
-  },
-  {
-    "method": "POST",
-    "path": "/billing/agents/{workloadId}/prices",
-    "body": { "priceRef": "calls-100", "displayName": "100 calls", "amountUsd": "5.00", "kind": "CREDIT_PACK", "credits": 100 }
-  },
-  {
-    "method": "POST",
-    "path": "/billing/agents/{workloadId}/prices",
-    "body": { "priceRef": "calls-1000", "displayName": "1,000 calls", "amountUsd": "40.00", "kind": "CREDIT_PACK", "credits": 1000 }
-  },
-  {
-    "method": "POST",
-    "path": "/agents/workloads/{workloadId}/deploy",
-    "body": null
-  }
-]

package/parity/deploy-plans/per-task-agent.json

@@ -1,34 +0,0 @@
-[
-  {
-    "method": "POST",
-    "path": "/agents/workloads",
-    "body": {
-      "name": "Per-task agent",
-      "services": [
-        {
-          "name": "agent",
-          "image": "ghcr.io/manyoars/per-task-agent@sha256:3dfe58ccacfcf8bf136e487e0dd6152092d26e6349f9671a2c46f78a097c07b3",
-          "port": 8080,
-          "public": true,
-          "cpuMillicores": 500,
-          "memoryMib": 512
-        }
-      ]
-    }
-  },
-  {
-    "method": "POST",
-    "path": "/billing/agents/{workloadId}/prices",
-    "body": { "priceRef": "task-1", "displayName": "1 task", "amountUsd": "9.00", "kind": "CREDIT_PACK", "credits": 1 }
-  },
-  {
-    "method": "POST",
-    "path": "/billing/agents/{workloadId}/prices",
-    "body": { "priceRef": "tasks-5", "displayName": "5 tasks", "amountUsd": "40.00", "kind": "CREDIT_PACK", "credits": 5 }
-  },
-  {
-    "method": "POST",
-    "path": "/agents/workloads/{workloadId}/deploy",
-    "body": null
-  }
-]