@iseoane/agent-depot 0.5.1 → 0.5.2

package/dist/src/self-update.js

@@ -0,0 +1,141 @@
+import { lstat, realpath } from "node:fs/promises";
+import path from "node:path";
+import { compareAppVersions } from "./app-version.js";
+import { createPortableExecutableResolver } from "./executable-resolution.js";
+import { runProcess } from "./process-runner.js";
+const REGISTRY_URL = "https://registry.npmjs.org";
+const MAX_REGISTRY_RESPONSE_BYTES = 8 * 1024;
+const MAX_NPM_STDERR_BYTES = 16 * 1024;
+const COMMAND_TIMEOUT_MS = 30_000;
+function compareVersions(left, right) {
+    const comparison = compareAppVersions(left, right);
+    if (comparison === undefined)
+        throw new Error(`Invalid semantic version comparison ${JSON.stringify(left)} and ${JSON.stringify(right)}`);
+    return comparison;
+}
+async function latestVersion(fetcher, packageName) {
+    const encodedName = encodeURIComponent(packageName).replace(/^%40/u, "@");
+    const response = await fetcher(`${REGISTRY_URL}/${encodedName}/latest`, {
+        signal: AbortSignal.timeout(10_000),
+        credentials: "omit",
+        redirect: "error",
+    });
+    if (!response.ok)
+        throw new Error(`npm registry returned HTTP ${response.status}`);
+    const contentLength = Number(response.headers.get("content-length"));
+    if (Number.isFinite(contentLength) && contentLength > MAX_REGISTRY_RESPONSE_BYTES) {
+        throw new Error("npm registry response exceeded the size limit");
+    }
+    if (!response.body)
+        throw new Error("npm registry response did not include a body");
+    const reader = response.body.getReader();
+    const chunks = [];
+    let responseBytes = 0;
+    try {
+        for (;;) {
+            const chunk = await reader.read();
+            if (chunk.done)
+                break;
+            responseBytes += chunk.value.byteLength;
+            if (responseBytes > MAX_REGISTRY_RESPONSE_BYTES) {
+                await reader.cancel();
+                throw new Error("npm registry response exceeded the size limit");
+            }
+            chunks.push(chunk.value);
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+    const body = Buffer.concat(chunks).toString("utf8");
+    let payload;
+    try {
+        payload = JSON.parse(body);
+    }
+    catch {
+        throw new Error("npm registry returned invalid JSON");
+    }
+    if (typeof payload !== "object" || payload === null || !("version" in payload) || typeof payload.version !== "string") {
+        throw new Error("npm registry response did not contain a version");
+    }
+    compareVersions(payload.version, payload.version);
+    return payload.version;
+}
+function successfulStdout(result) {
+    if (result.code !== 0 || result.signal !== null || result.timedOut || result.outputTooLarge)
+        return undefined;
+    return result.stdout.toString("utf8").trim();
+}
+export function createSelfUpdateOperations(options) {
+    const resolveExecutable = options.resolveExecutable ?? createPortableExecutableResolver();
+    const run = options.run ?? runProcess;
+    const fetcher = options.fetch ?? globalThis.fetch;
+    async function npmGlobalExecutable() {
+        const npm = await resolveExecutable("npm");
+        if (npm.blocked || npm.executable === undefined)
+            return undefined;
+        const target = await realpath(npm.executable).catch(() => undefined);
+        if (target === undefined || path.basename(target) !== "npm-cli.js" || path.basename(path.dirname(target)) !== "bin" || path.basename(path.dirname(path.dirname(target))) !== "npm")
+            return undefined;
+        let rootResult;
+        try {
+            rootResult = await run(npm.executable, ["root", "--global", "--silent", "--logs-max=0", "--no-update-notifier"], {
+                captureStdout: true,
+                maxOutputBytes: 4096,
+                maxStderrBytes: MAX_NPM_STDERR_BYTES,
+                timeoutMs: COMMAND_TIMEOUT_MS,
+            });
+        }
+        catch {
+            return undefined;
+        }
+        const globalRoot = successfulStdout(rootResult);
+        if (globalRoot === undefined || !path.isAbsolute(globalRoot))
+            return undefined;
+        const installedPackagePath = path.join(globalRoot, ...options.packageName.split("/"));
+        const installedPackage = await lstat(installedPackagePath).catch(() => undefined);
+        if (installedPackage === undefined || !installedPackage.isDirectory())
+            return undefined;
+        const actualRoot = await realpath(options.packageRoot).catch(() => undefined);
+        const reportedRoot = await realpath(installedPackagePath).catch(() => undefined);
+        return actualRoot !== undefined && actualRoot === reportedRoot ? npm.executable : undefined;
+    }
+    return {
+        async check() {
+            compareVersions(options.packageVersion, options.packageVersion);
+            const npm = await npmGlobalExecutable();
+            if (npm === undefined) {
+                return { kind: "unsupported", reason: "this CLI is not verified in npm's global package directory" };
+            }
+            const latest = await latestVersion(fetcher, options.packageName);
+            const comparison = compareVersions(latest, options.packageVersion);
+            if (comparison === 0)
+                return { kind: "current", current: options.packageVersion, latest };
+            if (comparison < 0)
+                return { kind: "ahead", current: options.packageVersion, latest };
+            return { kind: "available", current: options.packageVersion, latest };
+        },
+        async apply(version) {
+            let comparison;
+            try {
+                comparison = compareVersions(version, options.packageVersion);
+            }
+            catch {
+                throw new Error(`Refusing invalid Agent Depot version ${JSON.stringify(version)}`);
+            }
+            if (comparison <= 0)
+                throw new Error(`Refusing to downgrade Agent Depot from ${options.packageVersion} to ${version}`);
+            const npm = await npmGlobalExecutable();
+            if (npm === undefined)
+                throw new Error("this CLI is not verified in npm's global package directory");
+            const result = await run(npm, [
+                "install", "--global", "--no-audit", "--no-fund", "--no-update-notifier", "--logs-max=0", "--ignore-scripts",
+                "--registry=https://registry.npmjs.org/", `${options.packageName}@${version}`,
+            ], { maxStderrBytes: MAX_NPM_STDERR_BYTES, timeoutMs: COMMAND_TIMEOUT_MS });
+            if (result.code !== 0 || result.signal !== null || result.timedOut || result.outputTooLarge) {
+                const detail = result.timedOut ? "timed out" : result.outputTooLarge ? "produced too much output" : result.signal ? `stopped by ${result.signal}` : `exited with code ${result.code ?? "unknown"}`;
+                throw new Error(`npm global update ${detail}${result.stderr ? `: ${result.stderr.trim()}` : ""}`);
+            }
+        },
+    };
+}

package/dist/src/tui/package-rows.js

@@ -10,12 +10,14 @@ export function packageVersionLabel(evidence) {
 export function installedEvidenceLabel(evidence) {
     switch (evidence.kind) {
         case "installed": {
+            if (evidence.version !== undefined) {
+                const qualifier = evidence.reason === undefined ? "" : " (HEAD; local changes)";
+                return `installed ${evidence.version}${qualifier}`;
+            }
             if (evidence.reason !== undefined) {
                 const reason = evidence.reason.includes("local modifications") ? "local changes" : evidence.reason;
                 return `installed (version unavailable: ${reason})`;
             }
-            if (evidence.version !== undefined)
-                return `installed ${evidence.version}`;
             if (evidence.commit !== undefined)
                 return `installed at ${evidence.commit.slice(0, 7)}`;
             return "installed with no version evidence";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@iseoane/agent-depot",
-  "version": "0.5.1",
+  "version": "0.5.2",
   "description": "A cross-platform catalog for reusable coding-agent skills.",
   "license": "MIT",
   "author": "iseoane",
@@ -26,6 +26,7 @@
   "files": [
     "dist/src",
     "!dist/src/**/*.map",
+    "resources/pi",
     "skills",
     "!skills/**/test_*.py",
     "!skills/**/testdata",
@@ -41,10 +42,39 @@
   "engines": {
     "node": ">=24"
   },
+  "peerDependencies": {
+    "@earendil-works/pi-tui": "^1.0.3",
+    "typebox": "^1.3.27"
+  },
+  "peerDependenciesMeta": {
+    "@earendil-works/pi-tui": {
+      "optional": true
+    },
+    "typebox": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@earendil-works/pi-tui": "1.0.3",
+    "@eslint/js": "^9.39.2",
+    "@homebridge/node-pty-prebuilt-multiarch": "^0.14.1",
+    "@types/node": "^24.19.0",
+    "@types/react": "^19.3.0",
+    "eslint": "^9.39.2",
+    "ink-testing-library": "^4.0.0",
+    "typebox": "1.3.27",
+    "typescript": "^5.7.2",
+    "typescript-eslint": "^8.70.1"
+  },
+  "pi": {
+    "extensions": [
+      "./resources/pi/agents-panel/index.ts"
+    ]
+  },
   "scripts": {
     "build": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\" && tsc",
     "typecheck": "tsc --noEmit",
-    "lint": "eslint \"src/**/*.{ts,tsx}\" \"tests/**/*.{ts,tsx}\"",
+    "lint": "eslint \"src/**/*.{ts,tsx}\" \"resources/pi/**/*.{ts,tsx}\" \"tests/**/*.{ts,tsx}\"",
     "test": "pnpm build && node --test --import ./dist/tests/isolated-env.js \"dist/tests/*.test.js\"",
     "test:single": "pnpm build && node -e \"const { spawnSync } = require('node:child_process'); const input = process.argv[1] || 'tests/version.test.ts'; const file = input.replace(/^tests[\\\\/]/, 'dist/tests/').replace(/\\\\.ts$/i, '.js'); process.exit(spawnSync(process.execPath, ['--import', './dist/tests/isolated-env.js', '--test', file], { stdio: 'inherit' }).status ?? 1);\"",
     "test:coverage": "node -e \"require('node:fs').rmSync('coverage',{recursive:true,force:true})\" && tsc -p tsconfig.coverage.json && node -e \"const { spawnSync } = require('node:child_process'); process.exit(spawnSync(process.execPath, ['--enable-source-maps','--import','./dist/tests/isolated-env.js','--test','--test-reporter=dot','dist/tests/*.test.js'], { stdio: 'inherit', env: { ...process.env, NODE_V8_COVERAGE: 'coverage/v8' } }).status ?? 1);\"",
@@ -56,16 +86,6 @@
     "prepublishOnly": "pnpm build && pnpm test",
     "test:pack": "pnpm build && node scripts/pack-smoke.mjs"
   },
-  "devDependencies": {
-    "@eslint/js": "^9.39.2",
-    "@homebridge/node-pty-prebuilt-multiarch": "^0.14.1",
-    "@types/node": "^24.19.0",
-    "@types/react": "^19.3.0",
-    "eslint": "^9.39.2",
-    "ink-testing-library": "^4.0.0",
-    "typescript": "^5.7.2",
-    "typescript-eslint": "^8.70.1"
-  },
   "dependencies": {
     "ink": "^7.1.1",
     "react": "^19.3.0"

package/resources/pi/agents-panel/contract.ts

@@ -0,0 +1,62 @@
+import { Type, type Static } from "typebox";
+import { Value } from "typebox/value";
+
+const agentActivitySchema = Type.Object({
+  label: Type.String(),
+  at: Type.Number(),
+});
+
+const agentUsageSchema = Type.Object({
+  input: Type.Optional(Type.Number()),
+  output: Type.Optional(Type.Number()),
+  cacheRead: Type.Optional(Type.Number()),
+  cacheWrite: Type.Optional(Type.Number()),
+  totalTokens: Type.Optional(Type.Number()),
+  cost: Type.Optional(Type.Number()),
+});
+
+const agentSchema = Type.Object({
+  id: Type.String(),
+  description: Type.String(),
+  subagentType: Type.String(),
+  model: Type.String(),
+  thinking: Type.Optional(Type.String()),
+  readonly: Type.Boolean(),
+  status: Type.Union([
+    Type.Literal("running"),
+    Type.Literal("completed"),
+    Type.Literal("failed"),
+    Type.Literal("stopped"),
+  ]),
+  kind: Type.Union([Type.Literal("local"), Type.Literal("remote"), Type.Literal("ended")]),
+  pid: Type.Optional(Type.Number()),
+  startedAt: Type.String(),
+  endedAt: Type.Optional(Type.String()),
+  elapsedMs: Type.Number(),
+  observed: Type.Boolean(),
+  activity: Type.Optional(agentActivitySchema),
+  usage: Type.Optional(agentUsageSchema),
+  worktree: Type.Optional(Type.String()),
+});
+
+export const agentSnapshotRequestSchema = Type.Object({
+  version: Type.Literal(1),
+  requestId: Type.String(),
+});
+
+export const agentSnapshotResponseSchema = Type.Object({
+  version: Type.Literal(1),
+  requestId: Type.String(),
+  agents: Type.Array(agentSchema),
+});
+
+export type AgentSnapshot = Static<typeof agentSchema>;
+export type AgentSnapshotRequest = Static<typeof agentSnapshotRequestSchema>;
+export type AgentSnapshotResponse = Static<typeof agentSnapshotResponseSchema>;
+
+export const AGENT_SNAPSHOT_REQUEST_EVENT = "agent-depot:agents:v1:request";
+export const AGENT_SNAPSHOT_RESPONSE_EVENT = "agent-depot:agents:v1:snapshot";
+
+export function parseAgentSnapshotResponse(value: unknown): AgentSnapshotResponse | undefined {
+  return Value.Check(agentSnapshotResponseSchema, value) ? value : undefined;
+}