@zenera/cli 1.1.16 → 1.1.18

package/dist/commands/inspect.js

@@ -5,31 +5,39 @@ import { readFile, writeFile } from 'node:fs/promises';
 import { createServer } from 'node:http';
 import { extname, join, normalize, resolve, sep } from 'node:path';
 import { parse } from "../args.js";
+import { sessionIds } from "../projects.js";
 import { project as resolveProject } from "../resolve.js";
-import { display, newestRun, newestSession, requireSession, runPaths, sessionPaths, } from "../session.js";
-import { bold, cyan, dim, invalidError, json, note, write } from "../term.js";
+import { display, listRuns, listSessions, newestRun, requireSession, runPaths, sessionPaths, } from "../session.js";
+import { ago, bold, choose, cyan, dim, invalidError, isInteractive, json, note, write, } from "../term.js";
 const USAGE = 'zen inspect [run] [--session <id>] [--open] [--rebuild] [--serve [port]]';
 export const inspect = {
     summary: "Open or rebuild a run's report.html.",
     usage: USAGE,
     details: [
-        'With no arguments: the newest run of the newest session.',
+        'With no arguments: asks which session and run, or takes the newest of',
+        'each when there is nothing to ask on.',
         '--serve starts a local server, which the report needs for its assets.',
+        '--memory <dir> reads that memory instead of the project’s, for a run',
+        'that was given `zen run --memory`.',
     ],
     run: async (ctx) => {
         const { values, positionals } = parse(ctx.args, {
             project: { type: 'string' },
             session: { type: 'string' },
+            memory: { type: 'string' },
             open: { type: 'boolean' },
             rebuild: { type: 'boolean' },
             serve: { type: 'string' },
         }, USAGE);
         const found = await resolveProject({ cwd: ctx.cwd, project: values.project });
         const dir = found.dir;
-        const session = pickSession(dir, values.session);
-        const run = pickRun(session, positionals[0]);
+        // Asking is only possible at a terminal, and only honest when the
+        // answer is not being parsed by something.
+        const asking = isInteractive() && !ctx.json;
+        const session = await pickSession(dir, values.session, positionals[0], asking);
+        const run = await pickRun(session, positionals[0], asking);
         if (values.rebuild || !existsSync(run.report)) {
-            await rebuild(session, run, await memory(dir));
+            await rebuild(session, run, await memory(dir, values.memory, ctx.cwd));
         }
         if (ctx.json) {
             json({ session: session.id, run: run.id, report: run.report });
@@ -52,17 +60,73 @@ export const inspect = {
 // ---------------------------------------------------------------------------
 // Choosing what to show
 // ---------------------------------------------------------------------------
-function pickSession(dir, asked) {
+/**
+ * Which session to read. With nothing named and a terminal to ask on, the
+ * person picks: "the newest" is a guess about which of a dozen runs they meant,
+ * and a wrong guess looks the same as a broken command.
+ */
+async function pickSession(dir, asked, run, asking) {
     if (asked) {
         return requireSession(dir, asked);
     }
-    const newest = newestSession(dir);
-    if (!newest) {
+    if (sessionIds(dir).length === 0) {
         throw invalidError('nothing has been run here yet', 'start one: zen run');
     }
-    return sessionPaths(dir, newest);
+    // A named run answers the question itself: it is in whichever session holds it.
+    if (!asking || run) {
+        return newestWorked(dir, run);
+    }
+    const worked = (await listSessions(dir)).filter((s) => s.runs > 0);
+    if (worked.length === 0) {
+        throw invalidError('no runs yet — every session is empty', 'start one: zen run');
+    }
+    return await choose('Which session?', worked.map((s) => ({
+        label: s.id,
+        detail: [
+            s.title,
+            `${s.runs} run${s.runs === 1 ? '' : 's'}`,
+            ago(s.lastRunAt ?? s.createdAt),
+            s.busy ? 'running' : '',
+        ]
+            .filter(Boolean)
+            .join('  '),
+        value: sessionPaths(dir, s.id),
+    })));
 }
-function pickRun(session, asked) {
+/**
+ * The newest session that has a report to show — not simply the newest. A
+ * session exists before its first run and outlives one that never recorded
+ * anything, so the newest is routinely empty and picking it blindly answers
+ * "has no runs" about a project full of them.
+ */
+function newestWorked(dir, run) {
+    for (const id of sessionIds(dir).reverse()) {
+        const session = sessionPaths(dir, id);
+        if (run ? existsSync(runPaths(session, run).dir) : newestRun(session)) {
+            return session;
+        }
+    }
+    throw invalidError(run ? `no run ${run} in any session` : 'no runs yet — every session is empty', run ? 'see: zen list --sessions' : 'start one: zen run');
+}
+async function pickRun(session, asked, asking) {
+    if (!asked && asking) {
+        const runs = await listRuns(session);
+        if (runs.length === 0) {
+            throw invalidError(`session ${session.id} has no runs`);
+        }
+        // One run is not a question.
+        return await choose(`Which run of ${session.id}?`, runs.map((r) => ({
+            label: r.id,
+            detail: [
+                r.agent,
+                r.error ? 'failed' : r.stopReason,
+                ago(r.finishedAt ?? r.startedAt),
+            ]
+                .filter(Boolean)
+                .join('  '),
+            value: runPaths(session, r.id),
+        })));
+    }
     const id = asked ?? newestRun(session);
     if (!id) {
         throw invalidError(`session ${session.id} has no runs`);
@@ -98,9 +162,9 @@ async function rebuild(session, run, store) {
  * has the shape of what the run recalled but not a word of it; a run that
  * never touched memory pays nothing, because the report asks for no node.
  */
-async function memory(dir) {
+async function memory(dir, override, cwd) {
     const { config } = readProjectConfig(dir);
-    const at = memoryDir(dir, config);
+    const at = memoryDir(dir, config, override && resolve(cwd, override));
     if (!at || !existsSync(join(at, 'manifest.json'))) {
         return undefined;
     }

package/dist/commands/key.js

@@ -454,10 +454,57 @@ const env = async (ctx, args) => {
 function shellQuote(value) {
     return `'${value.replaceAll("'", `'\\''`)}'`;
 }
+/**
+ * One credential on stdout, alone, for a tool that wants a fresh one before
+ * every request rather than an export that goes stale — `zen meta` hands this
+ * to copilot as `COPILOT_PROVIDER_API_KEY_COMMAND`.
+ *
+ * A stored secret is simply printed. A service-account file is exchanged for
+ * an OAuth access token, which is the part worth having a command for: those
+ * last an hour, and a session does not.
+ */
+const token = async (ctx, args) => {
+    const { positionals } = parse(args, {}, 'zen key token <provider>[/name]');
+    const { provider, name } = parseRef(positionals[0] ?? 'vertex');
+    const store = await KeyStore.open();
+    const entry = name ? store.find(provider, name) : store.active(provider);
+    if (!entry) {
+        throw credentialError(`no ${provider} key`, `add one: zen key add ${provider}`);
+    }
+    if (entry.holds === 'secret') {
+        write(store.reveal(entry));
+        return;
+    }
+    const { GoogleAuth } = await import('google-auth-library');
+    const auth = new GoogleAuth({
+        keyFile: store.fileOf(entry),
+        scopes: ['https://www.googleapis.com/auth/cloud-platform'],
+    });
+    const access = await (await auth.getClient()).getAccessToken();
+    if (!access.token) {
+        throw credentialError(`${keyId(entry)} minted no token`, 'check the service account is still enabled');
+    }
+    if (ctx.json) {
+        json({ key: keyId(entry), token: access.token });
+        return;
+    }
+    write(access.token);
+};
 // ---------------------------------------------------------------------------
 // Dispatch
 // ---------------------------------------------------------------------------
-const SUBS = { ls, list: ls, add, use, check, rm, remove: rm, show, env };
+const SUBS = {
+    ls,
+    list: ls,
+    add,
+    use,
+    check,
+    rm,
+    remove: rm,
+    show,
+    env,
+    token,
+};
 export const key = {
     summary: 'The credential store: add, choose, verify and export API keys.',
     usage: USAGE,
@@ -480,6 +527,7 @@ export const key = {
         '  zen key rm <provider>/<name>      Forget one.',
         '  zen key show <ref> [--reveal]     Masked by default.',
         '  zen key env [provider …]          Shell exports, for other tools.',
+        '  zen key token [ref]               One credential on stdout, minted now.',
     ],
     run: async (ctx) => {
         const [name, ...rest] = ctx.args;

package/dist/commands/memory.js

@@ -2,7 +2,7 @@ import { ALL_AGENTS, buildMemoryReport, hostPath, memoryDir, MemoryIndex, Memory
 import { spawn } from 'node:child_process';
 import { existsSync } from 'node:fs';
 import { writeFile } from 'node:fs/promises';
-import { isAbsolute, join, resolve } from 'node:path';
+import { basename, isAbsolute, join, resolve } from 'node:path';
 import { parse } from "../args.js";
 import { project as resolveProject } from "../resolve.js";
 import { ago, bold, bytes, confirm, count, cyan, dim, green, isInteractive, json, note, table, usageError, write, writeAll, yellow, } from "../term.js";
@@ -39,6 +39,7 @@ export const memory = {
         '  forget <id...>         Remove nodes, their vectors and their files.',
         '',
         '  --project <name|dir>   Which project. Defaults to the one you are in.',
+        '  --dir <dir>            Read this memory directory instead of the project’s.',
         '  --kind <name>          Only this kind of node.',
         '  --audience <name>      Only nodes committed under this label.',
         '  --files                Only nodes that remember a file.',
@@ -59,6 +60,7 @@ export const memory = {
     run: async (ctx) => {
         const { values, positionals } = parse(ctx.args, {
             project: { type: 'string' },
+            dir: { type: 'string' },
             kind: { type: 'string' },
             audience: { type: 'string' },
             files: { type: 'boolean' },
@@ -73,7 +75,7 @@ export const memory = {
             throw usageError(`unknown subcommand: ${what}`, USAGE);
         }
         const rest = positionals.slice(1);
-        const opened = await open(ctx.cwd, values.project);
+        const opened = await open(ctx.cwd, values.project, values.dir);
         try {
             switch (what) {
                 case 'stats':
@@ -98,8 +100,19 @@ export const memory = {
  * project would resolve models and read every prompt file to inspect a graph
  * that needs none of it — and would fail on a project whose credentials are
  * missing, which is exactly when someone is debugging.
+ *
+ * A named directory is opened as it stands, project or no project: a graph
+ * copied out of a running session is the one most worth looking at, and it
+ * should not have to be given an `agents.yaml` first.
  */
-async function open(cwd, want) {
+async function open(cwd, want, at) {
+    if (at) {
+        const dir = resolve(cwd, at);
+        if (!existsSync(join(dir, 'manifest.json'))) {
+            throw usageError(`${dir} is not a memory`, 'no manifest.json in it');
+        }
+        return { store: await MemoryStore.open(dir), dir, project: basename(dir) };
+    }
     const project = await resolveProject({ cwd, project: want });
     const { config } = readProjectConfig(project.dir);
     const dir = memoryDir(project.dir, config);

package/dist/commands/meta.d.ts

@@ -0,0 +1,3 @@
+import type { Command } from '../command.ts';
+export declare const meta: Command;
+//# sourceMappingURL=meta.d.ts.map