@shardflux/cli 0.11.1 → 0.13.1

package/dist/project-sync.js

@@ -0,0 +1,243 @@
+import { randomUUID } from 'node:crypto';
+import { watch } from 'node:fs';
+import { lstat } from 'node:fs/promises';
+import { join } from 'node:path';
+import { AgentStateStore } from "./agent-state.js";
+import { projectWorkspacePath, seedAgentRepository } from "./agent-repository.js";
+import { contentIdentity, diffManifests, excludedSyncPath, ignoredProjectPaths, localManifest, MAX_SYNC_FILE_BYTES, parseManifest } from "./project-sync-manifest.js";
+import { applyLocalSyncFile, applyRemoteSyncBatch, readLocalSyncFile, readRemoteSyncFile } from "./project-sync-transfer.js";
+export { projectWorkspacePath } from "./agent-repository.js";
+/** L8 can read these reports without creating a watcher or touching a VM. */
+export function projectSyncConflicts(dir, key) {
+    const states = new AgentStateStore(dir).read().project_sync;
+    return (key ? states?.[key]?.conflicts ?? [] : Object.values(states ?? {}).flatMap((state) => state.conflicts)).slice();
+}
+/** Core reconciler used by the attach module and by the real Linux harness. */
+export function projectReconciler(options) {
+    const { folder, root, cell, agent, state, save, report, signal } = options;
+    if (!/^[a-z0-9][a-z0-9._-]{0,63}$/.test(agent))
+        throw new Error('invalid conflict agent name');
+    const cache = new Map();
+    let serial = Promise.resolve();
+    const run = async () => {
+        signal?.throwIfAborted();
+        const localRaw = await localManifest(folder, signal, cache, Object.keys(state.common));
+        const remoteRaw = await cell.files.manifest(root, { maxFileBytes: MAX_SYNC_FILE_BYTES, knownPaths: [...new Set([...Object.keys(state.common), ...localRaw.entries.map((entry) => entry.path)])], signal });
+        const localPaths = new Set(localRaw.entries.map((entry) => entry.path));
+        const alreadySkipped = new Set(localRaw.skipped.map((entry) => entry.path));
+        for (const path of await ignoredProjectPaths(folder, remoteRaw.entries.map((entry) => entry.path).filter((path) => !localPaths.has(path) && !alreadySkipped.has(path)), signal))
+            localRaw.skipped.push({ path, reason: 'ignored' });
+        const local = parseManifest(localRaw), remote = parseManifest(remoteRaw);
+        const blocked = new Set();
+        for (const [side, manifest] of [['local', localRaw], ['remote', remoteRaw]]) {
+            for (const skip of manifest.skipped) {
+                blocked.add(skip.path);
+                report(`Project sync skipped ${side} ${skip.path}: ${skip.reason}`);
+            }
+        }
+        const changes = diffManifests(local, remote, state.common, Date.now(), blocked);
+        let batch = new Map();
+        let expected = Object.create(null);
+        let batchBytes = 0;
+        const flush = async () => {
+            if (batch.size === 0)
+                return;
+            await applyRemoteSyncBatch(cell, root, batch, expected, signal);
+            batch = new Map();
+            expected = Object.create(null);
+            batchBytes = 0;
+        };
+        const upload = async (path, file, previous) => {
+            if (batch.size >= 128 || batchBytes + (file?.data.length ?? 0) > 8 << 20)
+                await flush();
+            batch.set(path, file);
+            expected[path] = previous;
+            batchBytes += file?.data.length ?? 0;
+        };
+        for (const change of changes) {
+            signal?.throwIfAborted();
+            const { path, winner } = change;
+            const winnerEntry = winner === 'local' ? local[path] : remote[path];
+            const loserEntry = winner === 'local' ? remote[path] : local[path];
+            if (change.conflict) {
+                let copy = `${path}.shard-conflict-${agent}`;
+                // Never overwrite a conflict from an earlier attach, even when Git
+                // ignores it. A suffix only appears when the required name is occupied.
+                try {
+                    await lstat(join(folder, copy));
+                    copy += `-${randomUUID()}`;
+                }
+                catch (error) {
+                    if (error.code !== 'ENOENT')
+                        throw error;
+                }
+                if (remote[copy])
+                    copy += `-${randomUUID()}`;
+                if (loserEntry) {
+                    const losing = winner === 'local' ? await readRemoteSyncFile(cell, root, loserEntry) : await readLocalSyncFile(folder, loserEntry);
+                    const backup = { ...losing, entry: { ...losing.entry, path: copy } };
+                    await applyLocalSyncFile(folder, copy, backup);
+                    await upload(copy, backup);
+                    // Preserve both copies before modifying either original.
+                    await flush();
+                }
+                const conflict = { path, copy: loserEntry ? copy : null, losingDeleted: !loserEntry, agent, winner, at: Date.now() };
+                state.conflicts.push(conflict);
+                save(state);
+                report(`Project sync conflict ${path}: ${winner} wins; ${conflict.copy ?? 'the other side deleted the file'}`);
+            }
+            const file = winnerEntry ? (winner === 'local' ? await readLocalSyncFile(folder, winnerEntry) : await readRemoteSyncFile(cell, root, winnerEntry)) : undefined;
+            if (winner === 'local')
+                await upload(path, file, remote[path]);
+            else
+                await applyLocalSyncFile(folder, path, file, local[path]);
+        }
+        await flush();
+        // Only observed equality advances the durable common hash. Changes made
+        // during transfer remain relative to the previous common hash on next run.
+        const [afterLocal, afterRemote] = changes.length === 0 ? [localRaw, remoteRaw] : await Promise.all([localManifest(folder, signal, cache, Object.keys(state.common)), cell.files.manifest(root, { maxFileBytes: MAX_SYNC_FILE_BYTES, knownPaths: Object.keys(state.common), signal })]);
+        const l = parseManifest(afterLocal), r = parseManifest(afterRemote);
+        for (const path of new Set([...Object.keys(l), ...Object.keys(r), ...Object.keys(state.common)])) {
+            if (blocked.has(path))
+                continue;
+            if (contentIdentity(l[path]) === contentIdentity(r[path])) {
+                if (l[path])
+                    state.common[path] = contentIdentity(l[path]);
+                else
+                    delete state.common[path];
+            }
+        }
+        save(state);
+    };
+    return () => { const next = serial.then(run); serial = next.catch(() => undefined); return next; };
+}
+export async function startProjectSync(ctx, ws, project) {
+    if (ws.labels.agent && ws.labels.agent !== 'main')
+        throw new Error('two-way project sync is only available for the main agent');
+    const root = projectWorkspacePath(project);
+    const cell = ws.cell({ agentLabel: ctx.agentLabel, transitionTimeoutMs: ctx.wakeTimeoutMs });
+    await cell.files.mkdir(root, { parents: true });
+    await seedAgentRepository(ctx, ws, project.folder, { root });
+    const store = new AgentStateStore(ctx.store.dir);
+    const key = `${ws.id}:${project.folder}`;
+    const states = store.read().project_sync;
+    const state = states?.[key] ?? { common: Object.create(null), conflicts: [] };
+    const save = (value) => {
+        store.update(doc => {
+            const current = (doc.project_sync ?? {});
+            current[key] = value;
+            doc.project_sync = current;
+        });
+    };
+    const report = (message) => { ctx.io.stderr.write(`${message}\n`); };
+    const reconcile = projectReconciler({ folder: project.folder, root, agent: ws.labels.agent ?? 'main', cell, state, save, report, signal: ctx.signal });
+    const abort = new AbortController();
+    const signal = ctx.signal ? AbortSignal.any([ctx.signal, abort.signal]) : abort.signal;
+    let stopped = false, dirty = false;
+    let timer;
+    let work = Promise.resolve();
+    const failures = [];
+    const schedule = () => {
+        if (stopped)
+            return;
+        dirty = true;
+        if (timer)
+            return;
+        timer = setTimeout(() => {
+            timer = undefined;
+            work = work.then(async () => {
+                while (dirty && !stopped) {
+                    dirty = false;
+                    await reconcile();
+                }
+            }).catch((error) => { failures.push(error); report(`Project sync failed: ${error instanceof Error ? error.message : String(error)}`); });
+        }, 35);
+    };
+    const local = watch(project.folder, { recursive: true }, (_event, file) => {
+        if (!file || ['.git/index', '.git/info/exclude'].includes(String(file)) || !excludedSyncPath(String(file)))
+            schedule();
+    });
+    local.on('error', (error) => { failures.push(error); report(`Project watch failed: ${error.message}`); });
+    let readyResolve;
+    let readyReject;
+    const ready = new Promise((resolve, reject) => { readyResolve = resolve; readyReject = reject; });
+    const onAbort = () => readyReject(signal.reason ?? new Error('project sync cancelled'));
+    signal.addEventListener('abort', onAbort, { once: true });
+    if (signal.aborted)
+        onAbort();
+    const readyTimeout = setTimeout(() => readyReject(new Error('guest project watch did not become ready within 30 seconds')), 30_000);
+    const remote = (async () => {
+        let reconnects = 0;
+        while (!signal.aborted) {
+            try {
+                for await (const event of cell.files.watch(root, { signal })) {
+                    if (event.ready) {
+                        reconnects = 0;
+                        readyResolve();
+                    }
+                    if (event.ready || event.rescan || event.paths.length > 0)
+                        schedule();
+                }
+                if (signal.aborted)
+                    break;
+                throw new Error('guest project watch disconnected');
+            }
+            catch (error) {
+                if (signal.aborted)
+                    break;
+                if (++reconnects > 3) {
+                    readyReject(error);
+                    failures.push(error);
+                    report(`Project watch stopped: ${error instanceof Error ? error.message : String(error)}`);
+                    break;
+                }
+                report('Project watch reconnecting; comparing manifests for detached edits');
+                await new Promise((resolve) => {
+                    const done = () => { clearTimeout(t); signal.removeEventListener('abort', done); resolve(); };
+                    const t = setTimeout(done, reconnects * 100);
+                    signal.addEventListener('abort', done, { once: true });
+                    if (signal.aborted)
+                        done();
+                });
+            }
+        }
+    })();
+    try {
+        await ready;
+        clearTimeout(readyTimeout);
+        signal.removeEventListener('abort', onAbort);
+        await reconcile();
+    }
+    catch (error) {
+        clearTimeout(readyTimeout);
+        signal.removeEventListener('abort', onAbort);
+        stopped = true;
+        local.close();
+        abort.abort();
+        if (timer)
+            clearTimeout(timer);
+        await remote;
+        await work;
+        throw error;
+    }
+    return {
+        root, conflicts: () => state.conflicts.slice(), reconcile,
+        async stop() {
+            if (stopped)
+                return;
+            stopped = true;
+            local.close();
+            if (timer)
+                clearTimeout(timer);
+            abort.abort();
+            await remote;
+            await work;
+            if (!ctx.signal?.aborted && dirty) {
+                dirty = false;
+                await reconcile();
+            }
+            if (failures.length)
+                throw new AggregateError(failures, 'project sync did not finish cleanly');
+        },
+    };
+}

package/dist/project-template-setup.d.ts

@@ -0,0 +1,17 @@
+import type { Workspace } from '@shardflux/sdk';
+import type { Ctx, Handler } from './commands.js';
+import { projectIdentity } from './project-identity.js';
+export declare function dependencyHash(folder: string): string;
+export declare function projectTemplateSlug(slug: string, identity: string): string;
+export declare function prepareProjectTemplate(ctx: Ctx, project: ReturnType<typeof projectIdentity>, existing: Workspace | null | undefined): Promise<{
+    template: string;
+    setupHash: string | undefined;
+    labels: {
+        shard_deps_hash: string;
+        shard_setup: string;
+        shard_setup_mode: string;
+        shard_template_slug: string;
+        shard_repo_remote: string;
+    };
+}>;
+export declare const PROJECT_TEMPLATE_HANDLERS: Record<string, Handler>;

package/dist/project-template-setup.js

@@ -0,0 +1,89 @@
+import { savedMachine } from "./filesystem-state.js";
+import { createHash } from 'node:crypto';
+import { lstatSync, readFileSync, readdirSync, readlinkSync } from 'node:fs';
+import { join } from 'node:path';
+import { execFileSync } from 'node:child_process';
+import { ShardfluxApiError } from '@shardflux/sdk';
+import { projectIdentity, normalizeRemote } from "./project-identity.js";
+// Hash format v2 matches services/guest-agent/internal/setup/hash.go.
+// Include manifests as well as locks: a changed dependency without a regenerated lock needs setup too.
+const dependencyNames = new Set(['package.json', 'package-lock.json', 'npm-shrinkwrap.json', 'pnpm-lock.yaml', 'yarn.lock', 'bun.lock', 'bun.lockb',
+    'pyproject.toml', 'poetry.lock', 'uv.lock', 'Pipfile', 'Pipfile.lock', 'Cargo.toml', 'Cargo.lock', 'go.mod', 'go.sum',
+    'go.work', 'go.work.sum', 'pnpm-workspace.yaml', '.nvmrc', '.node-version', '.python-version', '.go-version', 'rust-toolchain', 'rust-toolchain.toml',
+    'Gemfile', 'Gemfile.lock', 'composer.json', 'composer.lock', '.tool-versions', 'mise.toml', '.mise.toml']);
+const skippedDirs = new Set(['.git', 'node_modules', '.venv', 'venv', 'vendor', 'target', '.shard', '__pycache__', 'dist', 'build']);
+const dependencyName = (name) => dependencyNames.has(name) || /^requirements(?:[._-].*)?\.txt$/.test(name) || name.startsWith('Dockerfile') || /^(?:docker-)?compose(?:[._-].*)?\.ya?ml$/.test(name);
+export function dependencyHash(folder) {
+    let selected;
+    try {
+        selected = new Set(execFileSync('git', ['-C', folder, 'ls-files', '--cached', '--others', '--exclude-standard', '-z'], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'], maxBuffer: 32 * 1024 * 1024 }).split('\0'));
+    }
+    catch (error) {
+        if (error.status !== 128 && error.code !== 'ENOENT')
+            throw error;
+    }
+    const files = [];
+    const walk = (relative, devcontainer) => {
+        for (const name of readdirSync(join(folder, relative)).sort()) {
+            const path = relative ? `${relative}/${name}` : name;
+            const st = lstatSync(join(folder, path));
+            const inside = devcontainer || name === '.devcontainer';
+            if (st.isDirectory()) {
+                if (!skippedDirs.has(name))
+                    walk(path, inside);
+            }
+            else if ((st.isFile() || st.isSymbolicLink()) && (!selected || selected.has(path)) && name !== '.env' && !name.startsWith('.env.') && (inside || path.startsWith('.github/workflows/') || dependencyName(name)))
+                files.push(path);
+        }
+    };
+    walk('', false);
+    const hash = createHash('sha256').update('shardflux-deps-v2\0');
+    for (const path of files.sort((a, b) => Buffer.compare(Buffer.from(a), Buffer.from(b)))) {
+        const st = lstatSync(join(folder, path));
+        // Hash link targets, never read through a symlink outside the repository.
+        const content = st.isSymbolicLink() ? Buffer.from(readlinkSync(join(folder, path))) : readFileSync(join(folder, path));
+        hash.update(path).update('\0').update(st.isSymbolicLink() ? 'link\0' : 'file\0').update(String(content.length)).update('\0').update(content);
+    }
+    return hash.digest('hex');
+}
+export function projectTemplateSlug(slug, identity) {
+    if (/^[a-z0-9][a-z0-9-]{0,99}$/.test(slug) && !['coding', 'default', 'python-node-browser'].includes(slug))
+        return slug;
+    // Distinct dotted/underscored project keys must not collapse onto the same builder slug.
+    return `${slug.replace(/[._]/g, '-').slice(0, 89)}-${createHash('sha256').update(identity).digest('hex').slice(0, 10)}`;
+}
+export async function prepareProjectTemplate(ctx, project, existing) {
+    const depsHash = dependencyHash(project.folder);
+    const remote = project.remote ?? normalizeRemote(`file://${project.folder}`);
+    let binding;
+    try {
+        binding = await ctx.cloud().projectTemplates.get(remote, { signal: ctx.signal });
+    }
+    catch (err) {
+        if (!(err instanceof ShardfluxApiError && err.status === 404))
+            throw err;
+    }
+    if (binding && (!binding.template_slug || !Number.isInteger(binding.version) || binding.version < 1 || !/^[a-f0-9]{64}$/.test(binding.deps_hash)))
+        throw new Error('project template response omitted a valid slug, version or dependency hash');
+    const setup = !binding || binding.deps_hash !== depsHash;
+    // The builder only accepts lowercase letters, digits and hyphens. Keep L4's workspace identity unchanged.
+    const templateSlug = binding?.template_slug ?? projectTemplateSlug(project.slug, remote);
+    const machine = await savedMachine(ctx);
+    return {
+        template: existing?.template.slug ?? (binding ? `${binding.template_slug}@${binding.version}` : machine?.template ? `${machine.template.slug}@${machine.template.version}` : 'coding'),
+        setupHash: setup ? depsHash : undefined,
+        labels: { shard_deps_hash: depsHash, shard_setup: String(setup), shard_setup_mode: 'assisted-v2', shard_template_slug: templateSlug, shard_repo_remote: remote },
+    };
+}
+export const PROJECT_TEMPLATE_HANDLERS = {
+    async 'projects template'(ctx, _values, [path = './']) {
+        const project = projectIdentity(path);
+        const remote = project.remote ?? normalizeRemote(`file://${project.folder}`);
+        const binding = await ctx.cloud().projectTemplates.get(remote);
+        if (ctx.json)
+            ctx.io.stdout.write(`${JSON.stringify(binding)}\n`);
+        else
+            ctx.io.stdout.write(`${binding.template_slug}@${binding.version}\nDependencies: ${binding.deps_hash}\nUpdated: ${binding.updated_at}\n`);
+        return 0;
+    },
+};

package/dist/vault.d.ts

@@ -0,0 +1,16 @@
+import type { SiteCredential } from '@shardflux/sdk';
+export type Vault = 'hsec' | '1password' | 'bitwarden' | 'keychain';
+export declare const VAULT_SECURITY_NOTE = "Sent end to end from your vault to the workspace; Shardflux only relays encrypted bytes.";
+export declare const REMEMBERED_SECURITY_NOTE = "Stored encrypted with AWS KMS and filled straight into the page; agents never see it, and every use is logged.";
+export declare const SECRET_SECURITY_NOTE = "Stored encrypted with AWS KMS; only this project\u2019s workspaces can load it, and every load is logged.";
+export declare function vaultType(value?: string): Vault;
+/** The subprocess's stdout remains in memory. stderr is deliberately discarded:
+ * vault errors can echo item content. Names/references are the only argv data. */
+export declare function vaultOutput(vault: Vault, name: string, options?: {
+    signal?: AbortSignal;
+    keychain?: string;
+    env?: NodeJS.ProcessEnv;
+    item?: boolean;
+}): Promise<Buffer>;
+export declare function vaultValue(vault: Vault, name: string, options?: Parameters<typeof vaultOutput>[2]): Promise<string>;
+export declare function vaultCredential(vault: Vault, name: string, site: string, options?: Parameters<typeof vaultOutput>[2]): Promise<SiteCredential>;

package/dist/vault.js

@@ -0,0 +1,153 @@
+import { spawn } from 'node:child_process';
+import { UsageError } from "./errors.js";
+export const VAULT_SECURITY_NOTE = 'Sent end to end from your vault to the workspace; Shardflux only relays encrypted bytes.';
+export const REMEMBERED_SECURITY_NOTE = 'Stored encrypted with AWS KMS and filled straight into the page; agents never see it, and every use is logged.';
+export const SECRET_SECURITY_NOTE = 'Stored encrypted with AWS KMS; only this project’s workspaces can load it, and every load is logged.';
+export function vaultType(value) {
+    if (!['hsec', '1password', 'bitwarden', 'keychain'].includes(value ?? ''))
+        throw new UsageError('--from requires hsec, 1password, bitwarden or keychain');
+    return value;
+}
+/** The subprocess's stdout remains in memory. stderr is deliberately discarded:
+ * vault errors can echo item content. Names/references are the only argv data. */
+export function vaultOutput(vault, name, options = {}) {
+    if (!name || name.startsWith('-') || name.includes('\0'))
+        throw new UsageError('a vault item name or reference is required');
+    const command = vault === '1password' ? 'op' : vault === 'bitwarden' ? 'bw' : vault === 'keychain' ? '/usr/bin/security' : 'hsec';
+    const args = vault === '1password'
+        ? options.item
+            ? ['item', 'get', name, '--format', 'json']
+            : name.startsWith('op://')
+                ? ['read', name]
+                : ['item', 'get', name, '--format', 'json']
+        : vault === 'bitwarden'
+            ? ['get', options.item ? 'item' : 'password', name]
+            : vault === 'keychain'
+                ? ['find-generic-password', '-s', name, '-w', ...(options.keychain ? [options.keychain] : [])]
+                : ['get', name];
+    return new Promise((resolve, reject) => {
+        const child = spawn(command, args, { stdio: ['ignore', 'pipe', 'ignore'], env: options.env, signal: options.signal });
+        const chunks = [];
+        let size = 0;
+        let failed = false;
+        const timer = setTimeout(() => {
+            failed = true;
+            child.kill('SIGKILL');
+        }, 30_000);
+        child.stdout.on('data', (chunk) => {
+            size += chunk.length;
+            if (size > 65_538) {
+                failed = true;
+                child.kill('SIGKILL');
+            }
+            else
+                chunks.push(chunk);
+        });
+        child.on('error', () => {
+            clearTimeout(timer);
+            for (const b of chunks)
+                b.fill(0);
+            reject(new UsageError(`Could not read the item from ${vault}. Unlock your vault and retry.`));
+        });
+        child.on('close', (code) => {
+            clearTimeout(timer);
+            if (code !== 0 || failed) {
+                for (const b of chunks)
+                    b.fill(0);
+                reject(new UsageError(`Could not read the item from ${vault}. Unlock your vault and retry.`));
+                return;
+            }
+            const bytes = Buffer.concat(chunks);
+            for (const b of chunks)
+                b.fill(0);
+            resolve(bytes);
+        });
+    });
+}
+export async function vaultValue(vault, name, options = {}) {
+    const bytes = await vaultOutput(vault, name, options);
+    try {
+        // hsec is raw (including an intentional final newline); the other CLIs add
+        // a line ending. Preserve all other whitespace, including password spaces.
+        let value = new TextDecoder('utf-8', { fatal: true }).decode(bytes);
+        if (vault === '1password' && !name.startsWith('op://')) {
+            const item = JSON.parse(value);
+            const field = item.fields?.find((f) => f.purpose === 'PASSWORD' || f.id === 'password');
+            if (typeof field?.value !== 'string')
+                throw new Error('use a field reference');
+            value = field.value;
+        }
+        const text = vault === 'hsec' ? value : value.replace(/\r?\n$/, '');
+        if (!text || Buffer.byteLength(text) > 65_536 || text.includes('\0'))
+            throw new Error('invalid value');
+        return text;
+    }
+    catch {
+        throw new UsageError(`The ${vault} item must contain UTF-8 text, 1–65536 bytes, without NUL.`);
+    }
+    finally {
+        bytes.fill(0);
+    }
+}
+export async function vaultCredential(vault, name, site, options = {}) {
+    const bytes = await vaultOutput(vault, name, { ...options, item: true });
+    try {
+        const decoded = new TextDecoder('utf-8', { fatal: true }).decode(bytes);
+        const text = vault === 'hsec' ? decoded : decoded.replace(/\r?\n$/, '');
+        let raw;
+        try {
+            raw = JSON.parse(text);
+        }
+        catch {
+            if (vault === '1password' || vault === 'bitwarden')
+                throw new Error('invalid item');
+            return { password: text };
+        }
+        if (!raw || typeof raw !== 'object')
+            throw new Error('invalid item');
+        const item = raw;
+        const knownSites = (item.urls?.map((u) => u.href) ?? item.login?.uris?.map((u) => u.uri) ?? (item.site ? [item.site] : [])).filter((u) => !!u);
+        if (knownSites.length &&
+            !knownSites.some((u) => {
+                try {
+                    return new URL(u).origin === site;
+                }
+                catch {
+                    return false;
+                }
+            }))
+            throw new Error('site mismatch');
+        let username = item.username ?? item.login?.username;
+        let password = item.password ?? item.login?.password;
+        let seed = item.totp_seed ?? item.login?.totp;
+        for (const field of item.fields ?? []) {
+            if (field.purpose === 'USERNAME' || field.id === 'username')
+                username = field.value;
+            if (field.purpose === 'PASSWORD' || field.id === 'password')
+                password = field.value;
+            if (field.type === 'OTP')
+                seed = field.value;
+        }
+        if (seed?.startsWith('otpauth:')) {
+            const u = new URL(seed);
+            if (u.searchParams.get('algorithm') && !['SHA1', 'sha1'].includes(u.searchParams.get('algorithm')))
+                throw new Error('unsupported totp');
+            if (u.searchParams.get('period') && u.searchParams.get('period') !== '30')
+                throw new Error('unsupported totp');
+            if (u.searchParams.get('digits') && u.searchParams.get('digits') !== '6')
+                throw new Error('unsupported totp');
+            seed = u.searchParams.get('secret') ?? undefined;
+        }
+        if (seed && !/^[A-Za-z2-7]+=*$/.test(seed))
+            throw new Error('invalid totp');
+        if (!password && !username && !seed)
+            throw new Error('empty item');
+        return { ...(username ? { username } : {}), ...(password ? { password } : {}), ...(seed ? { totp_seed: seed } : {}) };
+    }
+    catch {
+        throw new UsageError(`Could not read a matching login from ${vault}. Choose a login item for this site.`);
+    }
+    finally {
+        bytes.fill(0);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shardflux/cli",
-  "version": "0.11.1",
+  "version": "0.13.1",
   "type": "module",
   "description": "shard: the Shardflux command line. Create an account, sign in, set up keys and billing, then open, run commands in, move files to, suspend, resume and fork serverless agent workspaces.",
   "license": "Apache-2.0",
@@ -43,16 +43,23 @@
     "access": "public"
   },
   "dependencies": {
+    "classic-level": "3.0.0",
+    "smol-toml": "1.9.0",
+    "snappyjs": "0.7.0",
     "yaml": "2.9.1",
-    "@shardflux/sdk": "^0.16.1"
+    "@shardflux/sdk": "^0.18.0"
   },
   "devDependencies": {
     "@eslint/js": "10.0.1",
     "@types/node": "24.13.6",
     "eslint": "10.11.0",
+    "playwright": "1.62.1",
     "typescript": "5.9.3",
     "typescript-eslint": "8.70.1"
   },
+  "optionalDependencies": {
+    "@shardflux/menubar-darwin": "^0.1.0"
+  },
   "scripts": {
     "build": "node scripts/build.mjs",
     "typecheck": "tsc -p tsconfig.json --noEmit",