@hanzo/build 0.2.40 → 0.2.42

package/lib/ago.d.ts

@@ -0,0 +1,2 @@
+/** `just now`, `5m ago`, `3h ago`, `4d ago`, else the date, for an RFC 3339 instant; `—` for none. */
+export declare function ago(iso: string): string;

package/lib/ago.js

@@ -0,0 +1,18 @@
+/** `just now`, `5m ago`, `3h ago`, `4d ago`, else the date, for an RFC 3339 instant; `—` for none. */
+export function ago(iso) {
+    const t = Date.parse(iso);
+    if (!Number.isFinite(t))
+        return '—';
+    const minutes = Math.round((Date.now() - t) / 60000);
+    if (minutes < 1)
+        return 'just now';
+    if (minutes < 60)
+        return `${minutes}m ago`;
+    const hours = Math.round(minutes / 60);
+    if (hours < 24)
+        return `${hours}h ago`;
+    const days = Math.round(hours / 24);
+    if (days < 30)
+        return `${days}d ago`;
+    return new Date(t).toLocaleDateString();
+}

package/lib/api/auto.d.ts

@@ -1,27 +1,86 @@
 /**
- * Automations: flows that run themselves.
+ * Automations: a task that runs itself, on a schedule or when asked.
  *
- *   GET    /v1/auto/flows              {data: [flow]}   newest updated first
- *   GET    /v1/auto/flows/{id}         the flow and its latest version (the name)
- *   POST   /v1/auto/flows              a disabled draft
- *   POST   /v1/auto/flows/{id}/enable
- *   POST   /v1/auto/flows/{id}/disable
+ *   GET    /v1/auto/automations            {data: [automation]}
+ *   POST   /v1/auto/automations            create one: name and instructions
+ *   GET    /v1/auto/automations/{id}       one
+ *   PATCH  /v1/auto/automations/{id}       change it, or switch it on or off
+ *   DELETE /v1/auto/automations/{id}       delete it, its schedule and its runs
+ *   POST   /v1/auto/automations/{id}/run   {run: {id, status}}  one run, now
+ *   GET    /v1/auto/automations/{id}/runs  {data: [run]}        newest first
  *
- * The list page records the id and whether the trigger is armed. The name lives
- * on the latest version, so each row is read once more.
+ * Each run is one Dev run in this organization, started as the person who last
+ * saved what it does. A draft is a flow named and not yet told what to do: it
+ * runs once its instructions are saved.
  */
 import { type Target } from './call.ts';
-export interface Automation {
-    id: string;
+export type Kind = 'manual' | 'hourly' | 'daily' | 'weekdays' | 'weekly' | 'cron';
+export type Permissions = 'ask' | 'auto';
+/** When it runs, in the person's own words and zone. */
+export interface Schedule {
+    kind: Kind;
+    /** HH:MM, 24-hour, for daily, weekdays and weekly; 00:MM for hourly. */
+    at?: string;
+    /** mon … sun, for weekly. */
+    day?: string;
+    /** Five fields, for cron. */
+    cron?: string;
+    /** An IANA zone; the platform reads an absent one as UTC. */
+    tz?: string;
+}
+/** What an automation is: what the editor holds and the platform keeps. */
+export interface Draft {
     name: string;
-    /** ENABLED or DISABLED. */
+    instructions: string;
+    /** A model id, or null for Enso, the default. */
+    model: string | null;
+    schedule: Schedule;
+    permissions: Permissions;
+    notify: boolean;
+    enabled: boolean;
+}
+export interface Last {
+    id: string;
     status: string;
-    /** Unix milliseconds, or 0. */
-    updated: number;
+    at: string;
+    summary: string;
+}
+export interface Automation extends Draft {
+    id: string;
+    project: string | null;
+    /** Named and not yet told what to do: it never runs until its instructions are saved. */
+    draft: boolean;
+    /** When it runs next, RFC 3339, or null when it runs only when asked or is off. */
+    next: string | null;
+    last: Last | null;
+    created: string;
+    updated: string;
 }
-export declare function automation(raw: unknown): Automation | null;
-export declare function flows(t: Target): Promise<Automation[]>;
-/** A disabled draft. Creating it does not arm the trigger. */
-export declare function add(t: Target, name: string): Promise<Automation>;
-/** Arm or disarm the trigger. A disarmed flow can still be started on demand. */
-export declare function arm(t: Target, id: string, on: boolean): Promise<void>;
+/** One run: succeeded, failed, running, queued, skipped or refused. */
+export interface Run {
+    id: string;
+    status: string;
+    at: string;
+    finished: string | null;
+    summary: string;
+    /** The Dev run it started, or null when it started none. */
+    session: string | null;
+}
+/** One automation as the platform answers it, or null for a row with no id. */
+export declare function read(raw: unknown): Automation | null;
+export declare function automations(t: Target): Promise<Automation[]>;
+export declare function automation(t: Target, id: string): Promise<Automation>;
+export declare function create(t: Target, d: Draft): Promise<Automation>;
+/** What changed between two drafts, field by field: what a save sends. */
+export declare function changes(was: Draft, now: Draft): Partial<Draft>;
+/** Change an automation. A change to anything but `enabled` makes the caller the person it runs as. */
+export declare function save(t: Target, id: string, change: Partial<Draft>): Promise<Automation>;
+export declare function remove(t: Target, id: string): Promise<void>;
+/** Start one run now. While one is going, the platform records this start as skipped. */
+export declare function start(t: Target, id: string): Promise<{
+    id: string;
+    status: string;
+}>;
+export declare function runs(t: Target, id: string): Promise<Run[]>;
+/** A schedule the way a person says it. */
+export declare function words(s: Schedule): string;

package/lib/api/auto.js

@@ -1,67 +1,127 @@
 /**
- * Automations: flows that run themselves.
+ * Automations: a task that runs itself, on a schedule or when asked.
  *
- *   GET    /v1/auto/flows              {data: [flow]}   newest updated first
- *   GET    /v1/auto/flows/{id}         the flow and its latest version (the name)
- *   POST   /v1/auto/flows              a disabled draft
- *   POST   /v1/auto/flows/{id}/enable
- *   POST   /v1/auto/flows/{id}/disable
+ *   GET    /v1/auto/automations            {data: [automation]}
+ *   POST   /v1/auto/automations            create one: name and instructions
+ *   GET    /v1/auto/automations/{id}       one
+ *   PATCH  /v1/auto/automations/{id}       change it, or switch it on or off
+ *   DELETE /v1/auto/automations/{id}       delete it, its schedule and its runs
+ *   POST   /v1/auto/automations/{id}/run   {run: {id, status}}  one run, now
+ *   GET    /v1/auto/automations/{id}/runs  {data: [run]}        newest first
  *
- * The list page records the id and whether the trigger is armed. The name lives
- * on the latest version, so each row is read once more.
+ * Each run is one Dev run in this organization, started as the person who last
+ * saved what it does. A draft is a flow named and not yet told what to do: it
+ * runs once its instructions are saved.
  */
 import { call, seg } from './call.js';
 const str = (v) => (typeof v === 'string' ? v : '');
-const obj = (v) => v && typeof v === 'object' ? v : {};
-export function automation(raw) {
+const nullable = (v) => (typeof v === 'string' && v ? v : null);
+const obj = (v) => (v && typeof v === 'object' ? v : {});
+const KINDS = ['manual', 'hourly', 'daily', 'weekdays', 'weekly', 'cron'];
+function schedule(raw) {
+    const o = obj(raw);
+    const kind = KINDS.includes(o.kind) ? o.kind : 'manual';
+    const out = { kind };
+    for (const k of ['at', 'day', 'cron', 'tz'])
+        if (str(o[k]))
+            out[k] = str(o[k]);
+    return out;
+}
+/** One automation as the platform answers it, or null for a row with no id. */
+export function read(raw) {
     const o = obj(raw);
     const id = str(o.id);
     if (!id)
         return null;
-    const version = obj(o.version);
+    const last = obj(o.last);
     return {
         id,
-        name: str(version.displayName) || str(o.displayName) || id,
-        status: str(o.status) || 'DISABLED',
-        updated: typeof o.updated === 'number' ? o.updated : 0,
+        name: str(o.name) || id,
+        instructions: str(o.instructions),
+        project: nullable(o.project),
+        model: nullable(o.model),
+        schedule: schedule(o.schedule),
+        permissions: o.permissions === 'auto' ? 'auto' : 'ask',
+        notify: o.notify === true,
+        enabled: o.enabled === true,
+        draft: o.draft === true,
+        next: nullable(o.next),
+        last: str(last.id) ? { id: str(last.id), status: str(last.status), at: str(last.at), summary: str(last.summary) } : null,
+        created: str(o.created),
+        updated: str(o.updated),
     };
 }
-export async function flows(t) {
-    const raw = await call(t, 'GET', '/v1/auto/flows');
-    const data = Array.isArray(obj(raw).data) ? obj(raw).data : [];
-    const rows = data.map(automation).filter((a) => a !== null).slice(0, 40);
-    return Promise.all(rows.map(async (a) => {
-        if (a.name !== a.id)
-            return a;
-        try {
-            return automation(await call(t, 'GET', `/v1/auto/flows/${seg(a.id)}`)) ?? a;
-        }
-        catch {
-            return a;
-        }
-    }));
+/** The Dev run a transcript link opens: `…/dev?run=sess_…`. */
+function session(link) {
+    const m = str(link).match(/[?&]run=(sess_[0-9a-f]{32})\b/);
+    return m ? m[1] : null;
+}
+const list = (raw) => (Array.isArray(obj(raw).data) ? obj(raw).data : []);
+export async function automations(t) {
+    return list(await call(t, 'GET', '/v1/auto/automations'))
+        .map(read)
+        .filter((a) => a !== null);
+}
+export async function automation(t, id) {
+    const a = read(await call(t, 'GET', `/v1/auto/automations/${seg(id)}`));
+    if (!a)
+        throw new Error('The automation came back without an id');
+    return a;
+}
+export async function create(t, d) {
+    const a = read(await call(t, 'POST', '/v1/auto/automations', d));
+    if (!a)
+        throw new Error('The automation was created and came back without an id');
+    return a;
+}
+/** What changed between two drafts, field by field: what a save sends. */
+export function changes(was, now) {
+    const out = {};
+    for (const k of Object.keys(now)) {
+        if (JSON.stringify(was[k]) !== JSON.stringify(now[k]))
+            out[k] = now[k];
+    }
+    return out;
+}
+/** Change an automation. A change to anything but `enabled` makes the caller the person it runs as. */
+export async function save(t, id, change) {
+    const a = read(await call(t, 'PATCH', `/v1/auto/automations/${seg(id)}`, change));
+    if (!a)
+        throw new Error('The automation was saved and came back without an id');
+    return a;
+}
+export async function remove(t, id) {
+    await call(t, 'DELETE', `/v1/auto/automations/${seg(id)}`);
+}
+/** Start one run now. While one is going, the platform records this start as skipped. */
+export async function start(t, id) {
+    const run = obj(obj(await call(t, 'POST', `/v1/auto/automations/${seg(id)}/run`)).run);
+    return { id: str(run.id), status: str(run.status) };
 }
-/** A disabled draft. Creating it does not arm the trigger. */
-export async function add(t, name) {
-    const displayName = name.trim();
-    if (!displayName)
-        throw new Error('Name the automation');
-    const raw = await call(t, 'POST', '/v1/auto/flows', {
-        displayName,
-        trigger: {
-            name: 'trigger',
-            type: 'PIECE_TRIGGER',
-            displayName: 'Start',
-            strategy: 'MANUAL',
-            settings: { pieceName: 'core', triggerName: 'manual' },
-        },
-    });
-    const row = automation(raw);
-    if (!row)
-        throw new Error('The automation was created and did not come back named');
-    return row;
+export async function runs(t, id) {
+    return list(await call(t, 'GET', `/v1/auto/automations/${seg(id)}/runs`))
+        .map((raw) => {
+        const o = obj(raw);
+        return { id: str(o.id), status: str(o.status), at: str(o.at), finished: nullable(o.finished), summary: str(o.summary), session: session(o.transcript) };
+    })
+        .filter((r) => r.id);
 }
-/** Arm or disarm the trigger. A disarmed flow can still be started on demand. */
-export async function arm(t, id, on) {
-    await call(t, 'POST', `/v1/auto/flows/${seg(id)}/${on ? 'enable' : 'disable'}`);
+const DAYS = { mon: 'Mondays', tue: 'Tuesdays', wed: 'Wednesdays', thu: 'Thursdays', fri: 'Fridays', sat: 'Saturdays', sun: 'Sundays' };
+/** A schedule the way a person says it. */
+export function words(s) {
+    const zone = ` · ${s.tz || 'UTC'}`;
+    switch (s.kind) {
+        case 'manual':
+            return 'When you run it';
+        case 'hourly':
+            return `Every hour at :${(s.at ?? '00:00').slice(3) || '00'}`;
+        case 'daily':
+            return `Every day at ${s.at}${zone}`;
+        case 'weekdays':
+            return `Weekdays at ${s.at}${zone}`;
+        case 'weekly':
+            return `${DAYS[s.day ?? ''] ?? s.day} at ${s.at}${zone}`;
+        case 'cron':
+            return `Cron ${s.cron}${zone}`;
+    }
 }

package/lib/api/models.d.ts

@@ -1,14 +1,17 @@
+/**
+ * The models a run can be routed through, from the platform's own catalog.
+ *
+ *   GET /v1/models → {data: [{id, class, family, …}]}
+ *
+ * Read by `@hanzo/ui/models` `parseModels`, so a model's class and family are
+ * the gateway's fields, never guessed from its id. `ENSO` is the router: it
+ * picks a model per step, which is why it is the default, and a run that names
+ * it names no model at all.
+ */
+import { type ModelCatalogEntry } from '@hanzo/ui/models/catalog';
 import { type Target } from './call.ts';
-export interface Model {
-    id: string;
-    label: string;
-    /** Listed and never chosen. */
-    disabled?: boolean;
-    hint?: string;
-    /** Where a person asks for access to a model they cannot call. */
-    request?: string;
-}
-export declare const ENSO = "enso";
-/** A readable name for an id: `anthropic/claude-opus-5.5` → `Claude Opus 5.5`, `zen5-coder` → `Zen5 Coder`. */
-export declare function label(id: string): string;
+export { ENSO } from '@hanzo/ui/models/catalog';
+export type Model = ModelCatalogEntry;
 export declare function models(t: Target): Promise<Model[]>;
+/** The payer's plan usage, as `GET /v1/ai/limits` answers it: what a picker marks paused. */
+export declare function limits(t: Target, signal?: AbortSignal): Promise<unknown>;

package/lib/api/models.js

@@ -1,42 +1,20 @@
 /**
  * The models a run can be routed through, from the platform's own catalog.
  *
- *   GET /v1/models → {data: [{id, …}]}
+ *   GET /v1/models → {data: [{id, class, family, …}]}
  *
- * `enso` is the router: it picks a model per step, which is why it is the
- * default and why it is not a model a person has to understand to use.
- *
- * After what the gateway serves come the models nobody can call yet, from
- * @hanzo/ui's `RESEARCH`: listed so a person knows they exist, disabled so no
- * run is ever started on one, with where to ask for access.
+ * Read by `@hanzo/ui/models` `parseModels`, so a model's class and family are
+ * the gateway's fields, never guessed from its id. `ENSO` is the router: it
+ * picks a model per step, which is why it is the default, and a run that names
+ * it names no model at all.
  */
-import { RESEARCH } from '@hanzo/ui/models/catalog';
+import { parseModels } from '@hanzo/ui/models/catalog';
 import { call } from './call.js';
-export const ENSO = 'enso';
-/** A readable name for an id: `anthropic/claude-opus-5.5` → `Claude Opus 5.5`, `zen5-coder` → `Zen5 Coder`. */
-export function label(id) {
-    const tail = id.slice(id.lastIndexOf('/') + 1).replace(/:.*$/, '');
-    return tail
-        .split('-')
-        .filter(Boolean)
-        .map((w) => (/^\d/.test(w) ? w : w[0].toUpperCase() + w.slice(1)))
-        .join(' ');
-}
+export { ENSO } from '@hanzo/ui/models/catalog';
 export async function models(t) {
-    const raw = await call(t, 'GET', '/v1/models');
-    const rows = Array.isArray(raw?.data) ? raw.data : [];
-    const ids = rows
-        .map((r) => (r && typeof r === 'object' && typeof r.id === 'string' ? r.id : ''))
-        .filter((id) => id && !id.endsWith(':batch'));
-    const out = [...new Set([ENSO, ...ids])];
-    return [
-        ...out.map((id) => ({ id, label: label(id) })),
-        ...RESEARCH.filter((m) => !out.includes(m.id)).map((m) => ({
-            id: m.id,
-            label: m.label ?? label(m.id),
-            disabled: true,
-            hint: 'Research preview',
-            request: m.request,
-        })),
-    ];
+    return parseModels(await call(t, 'GET', '/v1/models'));
+}
+/** The payer's plan usage, as `GET /v1/ai/limits` answers it: what a picker marks paused. */
+export function limits(t, signal) {
+    return call(t, 'GET', '/v1/ai/limits', undefined, { signal });
 }

package/lib/automations.d.ts

@@ -0,0 +1,5 @@
+export declare function Automations(): import("react").JSX.Element;
+/** One automation: what it does and when, its switch, Run now, and its runs. `new` writes one. */
+export declare function Editor({ id }: {
+    id: string;
+}): import("react").JSX.Element;