@hanzo/build 0.2.9 → 0.2.11

package/lib/api/members.js

@@ -0,0 +1,88 @@
+/**
+ * Who is in the organization, and who has been asked to join it, as Hanzo IAM
+ * holds them.
+ *
+ *   GET    /v1/iam/memberships?org=              the roster: {status, data: [membership], data2: count}
+ *   GET    /v1/iam/invitations?owner=            {invitations, total} (org admin)
+ *   POST   /v1/iam/invitations                   issue one (org admin)
+ *   DELETE /v1/iam/invitations/{owner}/{name}    withdraw one (org admin)
+ *
+ * IAM decides the scope from the credential: a member reads the roster of an org
+ * they belong to, and only an admin of the org reads or writes its invitations.
+ * An invitation is a code IAM redeems when someone signs up with it; IAM sends
+ * no email of its own.
+ */
+import { call, query, seg } from './call.js';
+const str = (v) => (typeof v === 'string' ? v : '');
+const num = (v) => (typeof v === 'number' && Number.isFinite(v) ? v : 0);
+const obj = (v) => (v && typeof v === 'object' ? v : {});
+const arr = (v) => (Array.isArray(v) ? v : []);
+const ROLES = ['owner', 'admin', 'member'];
+export function member(raw) {
+    const m = obj(raw);
+    const user = str(m.user);
+    const role = str(m.role);
+    return {
+        user,
+        name: user.includes('/') ? user.slice(user.indexOf('/') + 1) : user,
+        role: ROLES.includes(role) ? role : 'member',
+        since: str(m.createdTime),
+    };
+}
+/** The org's people, owners first. Grants to a team or narrowed to one project are not the org's roster. */
+export async function roster(t, org) {
+    const raw = obj(await call(t, 'GET', `/v1/iam/memberships${query({ org })}`));
+    if (raw.status === 'error')
+        throw new Error(str(raw.msg) || 'IAM refused the roster');
+    const rank = (r) => ROLES.indexOf(r);
+    return arr(raw.data)
+        .map(obj)
+        .filter((m) => str(m.user) && !str(m.workspace) && !str(m.project))
+        .map(member)
+        .sort((a, b) => rank(a.role) - rank(b.role) || a.name.localeCompare(b.name));
+}
+export function invitation(raw) {
+    const i = obj(raw);
+    return {
+        owner: str(i.owner),
+        name: str(i.name),
+        email: str(i.email),
+        code: str(i.code),
+        seats: num(i.quota),
+        used: num(i.usedCount),
+        state: str(i.state),
+        created: str(i.createdTime) || str(i.createdAt),
+    };
+}
+export async function invitations(t, org) {
+    const raw = obj(await call(t, 'GET', `/v1/iam/invitations${query({ owner: org })}`));
+    return arr(raw.invitations).map(invitation).filter((i) => i.name);
+}
+/** An address that can receive an invitation. */
+export const EMAIL = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+/** Random hex, from the browser's own generator. */
+function hex(bytes) {
+    const b = new Uint8Array(bytes);
+    crypto.getRandomValues(b);
+    return Array.from(b, (x) => x.toString(16).padStart(2, '0')).join('');
+}
+/** Invite one address into the org: one seat, redeemable now, pinned to that address. */
+export async function invite(t, org, email) {
+    const address = email.trim().toLowerCase();
+    if (!EMAIL.test(address))
+        throw new Error(`${email.trim() || 'That'} is not an email address`);
+    const local = address.slice(0, address.indexOf('@')).replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 24);
+    return invitation(await call(t, 'POST', '/v1/iam/invitations', {
+        owner: org,
+        name: `invite-${local || 'member'}-${hex(3)}`,
+        displayName: address,
+        email: address,
+        code: hex(8),
+        quota: 1,
+        usedCount: 0,
+        state: 'Active',
+    }));
+}
+export async function revoke(t, i) {
+    await call(t, 'DELETE', `/v1/iam/invitations/${seg(i.owner)}/${seg(i.name)}`);
+}

package/lib/api/memory.d.ts

@@ -0,0 +1,25 @@
+/**
+ * What Hanzo remembers about the signed-in person, in the org they act in.
+ *
+ *   GET  /v1/ai/memory/list?limit=  {status, data: [memory]}, newest first
+ *   POST /v1/ai/memory/remember     {content} → {status, data: memory}
+ *   POST /v1/ai/memory/delete       {id: "<owner>/<name>"}
+ *
+ * The platform keys every memory on the validated caller and org, never on the
+ * request, so these read and change the caller's own and nobody else's. A
+ * refusal arrives in the envelope, usually under a 200.
+ */
+import { type Target } from './call.ts';
+export interface Memory {
+    /** `<owner>/<name>`, what a delete names. */
+    id: string;
+    content: string;
+    /** user, fact, … as the platform files it. */
+    kind: string;
+    /** When it was last written, as the platform wrote it. */
+    updated: string;
+}
+export declare function memoryOf(raw: unknown): Memory | null;
+export declare function memories(t: Target, limit?: number): Promise<Memory[]>;
+export declare function remember(t: Target, content: string): Promise<Memory | null>;
+export declare function forget(t: Target, id: string): Promise<void>;

package/lib/api/memory.js

@@ -0,0 +1,34 @@
+/**
+ * What Hanzo remembers about the signed-in person, in the org they act in.
+ *
+ *   GET  /v1/ai/memory/list?limit=  {status, data: [memory]}, newest first
+ *   POST /v1/ai/memory/remember     {content} → {status, data: memory}
+ *   POST /v1/ai/memory/delete       {id: "<owner>/<name>"}
+ *
+ * The platform keys every memory on the validated caller and org, never on the
+ * request, so these read and change the caller's own and nobody else's. A
+ * refusal arrives in the envelope, usually under a 200.
+ */
+import { call, query, unwrap } from './call.js';
+const str = (v) => (typeof v === 'string' ? v : '');
+export function memoryOf(raw) {
+    const o = (raw && typeof raw === 'object' ? raw : {});
+    const owner = str(o.owner);
+    const name = str(o.name);
+    if (!owner || !name)
+        return null;
+    return { id: `${owner}/${name}`, content: str(o.content), kind: str(o.kind), updated: str(o.updatedTime) || str(o.createdTime) };
+}
+export async function memories(t, limit = 100) {
+    const rows = unwrap(await call(t, 'GET', `/v1/ai/memory/list${query({ limit })}`));
+    return (Array.isArray(rows) ? rows : []).map(memoryOf).filter((m) => m !== null);
+}
+export async function remember(t, content) {
+    const said = content.trim();
+    if (!said)
+        throw new Error('Say what Hanzo should remember');
+    return memoryOf(unwrap(await call(t, 'POST', '/v1/ai/memory/remember', { content: said })));
+}
+export async function forget(t, id) {
+    unwrap(await call(t, 'POST', '/v1/ai/memory/delete', { id }));
+}

package/lib/api/places.d.ts

@@ -1,13 +1,13 @@
 /**
  * Where a run can run: the platform's sandbox, or one of the org's machines.
  *
- *   GET /v1/agent/targets → {targets: [...]}, newest first
+ *   GET /v1/agent/targets → {targets: [...]}, newest first (machines.ts)
  *
  * The sandbox is not a row the platform lists — it is what a run gets when it
  * names no target — so it is the first place here and carries no id. A machine
  * can take a run only while it is online.
  */
-import { type Target } from './call.ts';
+import type { Target } from './call.ts';
 export interface Place {
     /** `tgt_…`, or '' for the sandbox. */
     id: string;

package/lib/api/places.js

@@ -1,31 +1,8 @@
-/**
- * Where a run can run: the platform's sandbox, or one of the org's machines.
- *
- *   GET /v1/agent/targets → {targets: [...]}, newest first
- *
- * The sandbox is not a row the platform lists — it is what a run gets when it
- * names no target — so it is the first place here and carries no id. A machine
- * can take a run only while it is online.
- */
-import { call } from './call.js';
+import { machines } from './machines.js';
 export const SANDBOX = { id: '', label: 'Hanzo sandbox', kind: 'sandbox', status: 'online', capacity: '' };
-const str = (v) => (typeof v === 'string' ? v : '');
 export async function places(t) {
-    const raw = (await call(t, 'GET', '/v1/agent/targets')) ?? {};
-    const rows = Array.isArray(raw.targets) ? raw.targets : [];
-    const machines = rows
-        .map((r) => {
-        const o = (r && typeof r === 'object' ? r : {});
-        return {
-            id: str(o.id),
-            label: str(o.label) || str(o.host) || str(o.id),
-            kind: str(o.kind),
-            status: str(o.status),
-            capacity: str(o.capacity),
-        };
-    })
-        .filter((p) => p.id);
-    return [SANDBOX, ...machines];
+    const list = await machines(t);
+    return [SANDBOX, ...list.map(({ id, label, kind, status, capacity }) => ({ id, label, kind, status, capacity }))];
 }
 /** Whether a run sent here now would be taken. */
 export const ready = (p) => p.status === 'online';

package/lib/api/plugins.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Plugins: TypeScript connectors an org builds, and what this deployment mounts.
+ *
+ *   GET    /v1/tool/plugins/authored        {plugins: [plugin]}, newest first, each with its source
+ *   POST   /v1/tool/plugins/build           {name, provider?, source | spec} → 201 {bytes, generated, plugin}
+ *   DELETE /v1/tool/plugins/authored/{id}   {deleted}
+ *   GET    /v1/tool/plugins                 {plugins: [{name, enabled, prefixes}]}
+ *
+ * Building is the gate: the platform bundles the source and compiles it in the
+ * runtime that will run it, and keeps it only if both succeed — a failure is a
+ * 422 whose reason is the bundler's. A spec (an OpenAPI document or prose) has a
+ * model write the source, which comes back to be read. A plugin never carries a
+ * credential: it names the connectors provider whose credential it reads when it
+ * runs. The mounted list is the deployment's own subsystems, read-only.
+ */
+import { type Target } from './call.ts';
+export interface Plugin {
+    /** What a delete addresses. */
+    id: string;
+    name: string;
+    /** The connectors provider whose credential it reads, or ''. */
+    provider: string;
+    /** The TypeScript as written or generated. */
+    source: string;
+    /** When it was last built, Unix seconds. */
+    built: number;
+}
+export interface Mount {
+    name: string;
+    enabled: boolean;
+    prefixes: string[];
+}
+export interface Built {
+    plugin: Plugin;
+    /** The size of the bundle the runtime executes. */
+    bytes: number;
+    /** Whether a model wrote the source from a spec. */
+    generated: boolean;
+}
+/** A plugin's name: one lowercase path segment, the id it runs by. */
+export declare const NAME: RegExp;
+export declare function plugin(raw: unknown): Plugin;
+export declare function authored(t: Target): Promise<Plugin[]>;
+export declare function mounted(t: Target): Promise<Mount[]>;
+export interface Build {
+    name: string;
+    provider: string;
+    /** Exactly one of the two carries text. */
+    source: string;
+    spec: string;
+}
+/** Why a plugin cannot be built as it stands, or '' when it can. */
+export declare function refuse(b: Build): string;
+export declare function build(t: Target, b: Build): Promise<Built>;
+export declare function remove(t: Target, id: string): Promise<void>;

package/lib/api/plugins.js

@@ -0,0 +1,62 @@
+/**
+ * Plugins: TypeScript connectors an org builds, and what this deployment mounts.
+ *
+ *   GET    /v1/tool/plugins/authored        {plugins: [plugin]}, newest first, each with its source
+ *   POST   /v1/tool/plugins/build           {name, provider?, source | spec} → 201 {bytes, generated, plugin}
+ *   DELETE /v1/tool/plugins/authored/{id}   {deleted}
+ *   GET    /v1/tool/plugins                 {plugins: [{name, enabled, prefixes}]}
+ *
+ * Building is the gate: the platform bundles the source and compiles it in the
+ * runtime that will run it, and keeps it only if both succeed — a failure is a
+ * 422 whose reason is the bundler's. A spec (an OpenAPI document or prose) has a
+ * model write the source, which comes back to be read. A plugin never carries a
+ * credential: it names the connectors provider whose credential it reads when it
+ * runs. The mounted list is the deployment's own subsystems, read-only.
+ */
+import { call, seg } from './call.js';
+/** A plugin's name: one lowercase path segment, the id it runs by. */
+export const NAME = /^[a-z0-9][a-z0-9_-]{0,63}$/;
+const str = (v) => (typeof v === 'string' ? v : '');
+const num = (v) => (typeof v === 'number' && Number.isFinite(v) ? v : 0);
+const obj = (v) => (v && typeof v === 'object' ? v : {});
+const rows = (v) => (Array.isArray(v) ? v : []);
+export function plugin(raw) {
+    const o = obj(raw);
+    return { id: str(o.id), name: str(o.name), provider: str(o.provider), source: str(o.source), built: num(o.createdAt) };
+}
+export async function authored(t) {
+    return rows(obj(await call(t, 'GET', '/v1/tool/plugins/authored')).plugins).map(plugin).filter((p) => p.id);
+}
+export async function mounted(t) {
+    return rows(obj(await call(t, 'GET', '/v1/tool/plugins')).plugins)
+        .map((r) => {
+        const o = obj(r);
+        return { name: str(o.name), enabled: o.enabled === true, prefixes: rows(o.prefixes).map(str).filter(Boolean) };
+    })
+        .filter((m) => m.name);
+}
+/** Why a plugin cannot be built as it stands, or '' when it can. */
+export function refuse(b) {
+    if (!NAME.test(b.name))
+        return 'A name is one lowercase word: letters, digits, _ or -';
+    if (!b.source.trim() === !b.spec.trim())
+        return 'Give the TypeScript or the API it calls, one of the two';
+    return '';
+}
+export async function build(t, b) {
+    const why = refuse(b);
+    if (why)
+        throw new Error(why);
+    const body = { name: b.name };
+    if (b.provider.trim())
+        body.provider = b.provider.trim();
+    if (b.source.trim())
+        body.source = b.source;
+    else
+        body.spec = b.spec;
+    const r = obj(await call(t, 'POST', '/v1/tool/plugins/build', body));
+    return { plugin: plugin(r.plugin), bytes: num(r.bytes), generated: r.generated === true };
+}
+export async function remove(t, id) {
+    await call(t, 'DELETE', `/v1/tool/plugins/authored/${seg(id)}`);
+}

package/lib/api/pref.d.ts

@@ -0,0 +1,49 @@
+/**
+ * The signed-in person's own settings, as the platform keeps them for every
+ * Hanzo surface.
+ *
+ *   GET   /v1/pref → {prefs: {…}, updatedAt}   an empty document for someone who saved nothing
+ *   PATCH /v1/pref   {key: value | null}        a shallow merge; null deletes the key
+ *
+ * The document is one object shared by every surface, keyed per person and per
+ * org. This reads only the keys the builder owns and writes only those, so a
+ * key another surface saved is left as it was. A value this version does not
+ * recognise reads as unset rather than as a choice.
+ */
+import { type Target } from './call.ts';
+export type Theme = 'system' | 'light' | 'dark';
+export type Text = 'small' | 'medium' | 'large';
+export type Motion = 'system' | 'reduced';
+/** Where and how a new run starts when New has no choice of its own kept. */
+export interface Code {
+    model?: string;
+    effort?: 'low' | 'medium' | 'high';
+    mode?: 'build' | 'plan';
+    /** A machine's id, or '' for the sandbox. */
+    place?: string;
+}
+export interface Prefs {
+    theme?: Theme;
+    text?: Text;
+    motion?: Motion;
+    /** The dictation language, as voice.ts names it. */
+    language?: string;
+    /** What Hanzo calls the person. */
+    callName?: string;
+    /** What best describes their work. */
+    work?: string;
+    /** What every coding run is told about how they like to work. */
+    instructions?: string;
+    code?: Code;
+}
+/** A change: a key set to a value, or to null to delete it. */
+export type Patch = {
+    [K in keyof Prefs]?: Prefs[K] | null;
+};
+export declare function code(raw: unknown): Code | undefined;
+/** The builder's keys from a whole preference document. */
+export declare function prefs(raw: unknown): Prefs;
+/** What a document reads as once `patch` is merged into it — the platform's own rule. */
+export declare function merge(base: Prefs, patch: Patch): Prefs;
+export declare function read(t: Target): Promise<Prefs>;
+export declare function save(t: Target, patch: Patch): Promise<Prefs>;

package/lib/api/pref.js

@@ -0,0 +1,68 @@
+/**
+ * The signed-in person's own settings, as the platform keeps them for every
+ * Hanzo surface.
+ *
+ *   GET   /v1/pref → {prefs: {…}, updatedAt}   an empty document for someone who saved nothing
+ *   PATCH /v1/pref   {key: value | null}        a shallow merge; null deletes the key
+ *
+ * The document is one object shared by every surface, keyed per person and per
+ * org. This reads only the keys the builder owns and writes only those, so a
+ * key another surface saved is left as it was. A value this version does not
+ * recognise reads as unset rather than as a choice.
+ */
+import { call } from './call.js';
+const THEMES = ['system', 'light', 'dark'];
+const TEXTS = ['small', 'medium', 'large'];
+const MOTIONS = ['system', 'reduced'];
+const EFFORTS = ['low', 'medium', 'high'];
+const MODES = ['build', 'plan'];
+const obj = (v) => (v && typeof v === 'object' && !Array.isArray(v) ? v : {});
+const text = (v) => (typeof v === 'string' && v.trim() ? v : undefined);
+const one = (v, of) => (of.includes(v) ? v : undefined);
+/** Drop the keys that say nothing, so a read and a merge compare cleanly. */
+function defined(o) {
+    return Object.fromEntries(Object.entries(o).filter(([, v]) => v !== undefined));
+}
+export function code(raw) {
+    const c = obj(raw);
+    const out = defined({
+        model: text(c.model),
+        effort: one(c.effort, EFFORTS),
+        mode: one(c.mode, MODES),
+        place: typeof c.place === 'string' ? c.place : undefined,
+    });
+    return Object.keys(out).length ? out : undefined;
+}
+/** The builder's keys from a whole preference document. */
+export function prefs(raw) {
+    const p = obj(raw);
+    return defined({
+        theme: one(p.theme, THEMES),
+        text: one(p.text, TEXTS),
+        motion: one(p.motion, MOTIONS),
+        language: text(p.language),
+        callName: text(p.callName),
+        work: text(p.work),
+        instructions: text(p.instructions),
+        code: code(p.code),
+    });
+}
+/** What a document reads as once `patch` is merged into it — the platform's own rule. */
+export function merge(base, patch) {
+    const out = { ...base };
+    for (const [k, v] of Object.entries(patch)) {
+        if (v === null)
+            delete out[k];
+        else if (v !== undefined)
+            out[k] = v;
+    }
+    return prefs(out);
+}
+export async function read(t) {
+    const r = await call(t, 'GET', '/v1/pref');
+    return prefs(r?.prefs);
+}
+export async function save(t, patch) {
+    const r = await call(t, 'PATCH', '/v1/pref', patch);
+    return prefs(r?.prefs);
+}

package/lib/api/profile.d.ts

@@ -0,0 +1,21 @@
+/**
+ * The signed-in person's own profile on Hanzo IAM: the name they are shown by
+ * and their photo.
+ *
+ *   PUT  /v1/iam/account  {displayName} → {status, data: {owner, name, displayName, avatar, …}}
+ *   POST /v1/account/avatar  multipart `file` → {avatar}   the photo, also written to IAM
+ *
+ * Both act on the caller alone: neither request names a person. The email is a
+ * sign-in identifier and changes only through IAM's verification, never here.
+ */
+import { type Target } from './call.ts';
+export interface Profile {
+    displayName: string;
+    avatar: string;
+}
+/** Save the name the person is shown by. An empty name is refused here. */
+export declare function rename(t: Target, name: string): Promise<Profile>;
+/** The formats the platform keeps a photo in; it decides by the bytes, this only filters the picker. */
+export declare const PHOTO = "image/png,image/jpeg,image/gif,image/webp";
+/** Store a new photo and answer its address. */
+export declare function photo(t: Target, file: Blob): Promise<string>;

package/lib/api/profile.js

@@ -0,0 +1,40 @@
+/**
+ * The signed-in person's own profile on Hanzo IAM: the name they are shown by
+ * and their photo.
+ *
+ *   PUT  /v1/iam/account  {displayName} → {status, data: {owner, name, displayName, avatar, …}}
+ *   POST /v1/account/avatar  multipart `file` → {avatar}   the photo, also written to IAM
+ *
+ * Both act on the caller alone: neither request names a person. The email is a
+ * sign-in identifier and changes only through IAM's verification, never here.
+ */
+import { call, headers, reason, Refusal, unwrap } from './call.js';
+const str = (v) => (typeof v === 'string' ? v : '');
+const obj = (v) => (v && typeof v === 'object' ? v : {});
+/** Save the name the person is shown by. An empty name is refused here. */
+export async function rename(t, name) {
+    const displayName = name.trim();
+    if (!displayName)
+        throw new Error('A name cannot be empty');
+    const p = obj(unwrap(await call(t, 'PUT', '/v1/iam/account', { displayName })));
+    return { displayName: str(p.displayName), avatar: str(p.avatar) };
+}
+/** The formats the platform keeps a photo in; it decides by the bytes, this only filters the picker. */
+export const PHOTO = 'image/png,image/jpeg,image/gif,image/webp';
+const LIMIT = 8 << 20;
+/** Store a new photo and answer its address. */
+export async function photo(t, file) {
+    if (!file.size)
+        throw new Error('That file is empty');
+    if (file.size > LIMIT)
+        throw new Error('A photo is at most 8 MB');
+    const form = new FormData();
+    form.append('file', file);
+    const res = await fetch(`${t.api}/v1/account/avatar`, { method: 'POST', headers: headers(t), body: form, cache: 'no-store' });
+    if (!res.ok)
+        throw new Refusal(res.status, (await reason(res)) || `POST /v1/account/avatar answered ${res.status}`);
+    const url = str(obj(await res.json()).avatar);
+    if (!url.startsWith('https://'))
+        throw new Refusal(502, 'The photo was stored without an address this page can show');
+    return url;
+}

package/lib/api/projects.d.ts

@@ -1,10 +1,15 @@
 /**
  * The org's projects: what it has built, and where each one is served.
  *
- *   GET /v1/projects → Project[]
+ *   GET    /v1/projects         → Project[]
+ *   PATCH  /v1/projects/{slug}  rename it, or make it public or private
+ *   DELETE /v1/projects/{slug}  delete it and take its site down
  *
  * `slug` is the one key every surface shares — the address under /dev, the
- * site's name, the `project` a run is tagged with.
+ * site's name, the `project` a run is tagged with. A project belongs to the org,
+ * not to a person: the record names no author, so any member lists, changes and
+ * deletes it. Private is paid, and an unfunded org is refused rather than left
+ * public without being told.
  */
 import { type Target } from './call.ts';
 export interface Project {
@@ -17,12 +22,24 @@ export interface Project {
     status: string;
     /** The deployed address, or '' when nothing has shipped. */
     live: string;
+    /** `public` or `private`, or '' when the platform did not say. */
+    visibility: '' | Visibility;
+    /** Unix seconds; 0 when unknown. A deploy does not move `updated`. */
+    created: number;
     updated: number;
 }
+export type Visibility = 'public' | 'private';
 /** An address the preview may frame: https, or http on loopback when the builder is local too. */
 export declare function safe(url: string, local?: boolean): string;
 export declare function project(raw: unknown): Project;
 export declare function projects(t: Target): Promise<Project[]>;
+/** Change a project's name or who can see it; what is not sent is left as it is. */
+export declare function change(t: Target, slug: string, what: {
+    name?: string;
+    visibility?: Visibility;
+}): Promise<Project>;
+/** Delete a project. Its site stops answering and its slug is free again. */
+export declare function remove(t: Target, slug: string): Promise<void>;
 /** The repository name a project's clone URL names — the last path segment, without `.git`. */
 export declare function name(clone: string): string;
 /** A starter from the public catalog. */

package/lib/api/projects.js

@@ -1,13 +1,19 @@
 /**
  * The org's projects: what it has built, and where each one is served.
  *
- *   GET /v1/projects → Project[]
+ *   GET    /v1/projects         → Project[]
+ *   PATCH  /v1/projects/{slug}  rename it, or make it public or private
+ *   DELETE /v1/projects/{slug}  delete it and take its site down
  *
  * `slug` is the one key every surface shares — the address under /dev, the
- * site's name, the `project` a run is tagged with.
+ * site's name, the `project` a run is tagged with. A project belongs to the org,
+ * not to a person: the record names no author, so any member lists, changes and
+ * deletes it. Private is paid, and an unfunded org is refused rather than left
+ * public without being told.
  */
-import { call } from './call.js';
+import { call, seg } from './call.js';
 const str = (v) => (typeof v === 'string' ? v : '');
+const num = (v) => (typeof v === 'number' && Number.isFinite(v) ? v : 0);
 const loopback = (host) => host === 'localhost' || host === '127.0.0.1';
 /** Whether this page itself is served from loopback — local work. */
 const here = () => typeof window !== 'undefined' && loopback(window.location.hostname);
@@ -37,7 +43,9 @@ export function project(raw) {
         branch: str(repo.branch),
         status: str(p.status),
         live: safe(str(p.liveUrl)),
-        updated: typeof p.updatedAt === 'number' ? p.updatedAt : 0,
+        visibility: p.visibility === 'public' || p.visibility === 'private' ? p.visibility : '',
+        created: num(p.createdAt),
+        updated: num(p.updatedAt),
     };
 }
 export async function projects(t) {
@@ -48,6 +56,23 @@ export async function projects(t) {
         .filter((p) => p.slug)
         .sort((a, b) => b.updated - a.updated);
 }
+/** Change a project's name or who can see it; what is not sent is left as it is. */
+export async function change(t, slug, what) {
+    const body = {};
+    if (what.name !== undefined) {
+        const n = what.name.trim();
+        if (!n)
+            throw new Error('A project needs a name');
+        body.name = n;
+    }
+    if (what.visibility !== undefined)
+        body.visibility = what.visibility;
+    return project(await call(t, 'PATCH', `/v1/projects/${seg(slug)}`, body));
+}
+/** Delete a project. Its site stops answering and its slug is free again. */
+export async function remove(t, slug) {
+    await call(t, 'DELETE', `/v1/projects/${seg(slug)}`);
+}
 /** The repository name a project's clone URL names — the last path segment, without `.git`. */
 export function name(clone) {
     const cut = clone.replace(/\.git$/, '').replace(/\/+$/, '');

package/lib/api/provider.d.ts

@@ -0,0 +1,42 @@
+/**
+ * The organization's connectors: a Slack workspace, the GitHub accounts the
+ * platform's GitHub App is installed on.
+ *
+ *   GET  /v1/provider/{id}              one connector and this org's connection to it
+ *   POST /v1/provider/{id}/connect      {} → {authorizeUrl}: the provider's own consent page (org admin)
+ *   POST /v1/provider/{id}/disconnect   forget the org's connection (org admin)
+ *   GET  /v1/provider/slack/channels    the connected workspace's channels, a page at a time
+ *
+ * Connecting leaves this page once, for the provider's consent screen, and only
+ * for that provider's own host.
+ */
+import { type Target } from './call.ts';
+export interface Connector {
+    id: string;
+    name: string;
+    /** Whether this deployment can connect it at all. */
+    available: boolean;
+    connected: boolean;
+    /** The connected account's own name: the Slack workspace, the GitHub login. */
+    account: string;
+    since: string;
+    /** Why it cannot be connected here, when it cannot. */
+    note: string;
+}
+export declare function connector(raw: unknown, id?: string): Connector;
+export declare function read(t: Target, id: string): Promise<Connector>;
+/** The provider's consent page for this org. */
+export declare function authorize(t: Target, id: string): Promise<string>;
+export declare function disconnect(t: Target, id: string): Promise<void>;
+export interface Channel {
+    id: string;
+    name: string;
+    private: boolean;
+    /** Whether Hanzo has joined it. */
+    member: boolean;
+}
+export interface Channels {
+    channels: Channel[];
+    next: string;
+}
+export declare function channels(t: Target, cursor?: string): Promise<Channels>;