@platless/axom-cli 0.1.0 → 0.5.9

package/dist/workstation/qoderAdapter/subwork.js

@@ -0,0 +1,85 @@
+const object = (v) => v && typeof v === 'object' && !Array.isArray(v) ? v : {};
+const id = (v) => typeof v === 'string' && v.length > 0 && v.length <= 256 && !/[\x00-\x1f\x7f]/.test(v);
+export function newSubworkData() {
+    return { calls: {}, count: 0 };
+}
+export function supportsSubworkMeta(info) {
+    return (info?.name === 'qoder-cli' && info.version === '1.1.61') ||
+        (info?.name === 'axom-qoder-sdk' && info.version === '1.0.50');
+}
+function resultText(value) {
+    if (typeof value === 'string')
+        return value;
+    if (Array.isArray(value)) {
+        const texts = value.filter(v => object(v).type === 'text').map(v => object(v).text).filter(v => typeof v === 'string');
+        return texts.length ? texts.join('\n') : undefined;
+    }
+    const v = object(value);
+    if (v.kind === 'agent-result')
+        return resultText(v.content ?? v.result);
+    return undefined;
+}
+export class SubworkBoundary {
+    root;
+    data;
+    constructor(root, data = newSubworkData()) {
+        this.root = root;
+        this.data = data;
+    }
+    get(toolId) { return Object.hasOwn(this.data.calls, toolId) ? this.data.calls[toolId] : undefined; }
+    child(toolId) { return `qoder-agent:${this.root}:${toolId}`; }
+    map(event) {
+        if (event.acpSessionId && event.acpSessionId !== this.root)
+            return [event];
+        const p = event.payload, q = object(object(p._meta).qoder), input = object(p.rawInput);
+        const marked = q.version === 1 && ['native-acp-patch', 'sdk', 'correction'].includes(String(q.source));
+        const toolId = p.toolCallId;
+        let call = id(toolId) ? this.get(toolId) : undefined;
+        const parent = marked && q.route !== 'unknown' && id(q.parentToolUseId) ? q.parentToolUseId : undefined;
+        const events = [];
+        if (!call && marked && p.kind === 'think' && q.toolName === 'Agent' && id(toolId) &&
+            typeof input.prompt === 'string' && (input.subagent_type == null || typeof input.subagent_type === 'string') &&
+            (input.run_in_background === undefined || typeof input.run_in_background === 'boolean') &&
+            ['tool_call', 'tool_call_update'].includes(event.eventName) && this.data.count < 4096) {
+            call = { child: this.child(toolId), ...(parent ? { parent: this.child(parent) } : {}),
+                background: input.run_in_background === true, ended: false, streamedText: '' };
+            Object.defineProperty(this.data.calls, toolId, { value: call, enumerable: true, writable: true, configurable: true });
+            this.data.count += 1;
+            events.push({ eventName: 'subagent_spawned', payload: { subagentSessionId: call.child,
+                    name: typeof input.description === 'string' && input.description.trim() ? input.description : input.subagent_type ?? 'Agent',
+                    task: input.prompt, capabilities: {} }, ...(call.parent ? { acpSessionId: call.parent } : {}) });
+            events.push({ eventName: 'user_message_chunk', payload: { content: { type: 'text', text: input.prompt } }, acpSessionId: call.child });
+        }
+        if (call && ['tool_call', 'tool_call_update'].includes(event.eventName)) {
+            if (call.ended)
+                return events;
+            const output = object(p.rawOutput);
+            const state = output.kind === 'agent-result' ? output.state : undefined;
+            const terminal = state === 'completed' ? 'completed' : ['error', 'failed'].includes(String(state)) ? 'failed' :
+                state === 'cancelled' ? 'cancelled' : ['failed', 'cancelled'].includes(String(p.status)) ? p.status :
+                    !call.background && p.status === 'completed' ? 'completed' : undefined;
+            if (terminal) {
+                const text = resultText(p.rawOutput);
+                if (text !== undefined && !call.streamedText.endsWith(text))
+                    events.push({ eventName: 'agent_message_chunk',
+                        payload: { content: { type: 'text', text } }, acpSessionId: call.child });
+                events.push({ eventName: 'subagent_state_update', payload: { subagentSessionId: call.child, state: terminal },
+                    ...(call.parent ? { acpSessionId: call.parent } : {}) });
+                call.ended = true;
+                // Read only by the check above, once: an ended call keeps no stream (checkpointed state).
+                call.streamedText = '';
+            }
+            // The Agent invocation becomes a dispatch/result in subwork. Keeping the vendor tool here
+            // would also create the old delegation card for the very same task.
+            return events;
+        }
+        if (parent) {
+            const owner = this.get(parent), content = object(p.content);
+            if (owner && !owner.ended && event.eventName === 'agent_message_chunk' && content.type === 'text' && typeof content.text === 'string') {
+                owner.streamedText += content.text;
+            }
+            return [{ ...event, acpSessionId: this.child(parent) }];
+        }
+        return [event];
+    }
+}

package/dist/workstation/qoderAdapter/taskControl.js

@@ -0,0 +1,38 @@
+import { capabilitiesFor } from './profile.js';
+const validId = (value) => value.length > 0 && Buffer.byteLength(value, 'utf8') <= 256 &&
+    !/[\x00-\x1f\x7f]/.test(value);
+export class TaskControl {
+    ledger;
+    profile;
+    query;
+    certifications;
+    binding;
+    requests = new Map();
+    constructor(ledger, profile, query, certifications, binding) {
+        this.ledger = ledger;
+        this.profile = profile;
+        this.query = query;
+        this.certifications = certifications;
+        this.binding = binding;
+    }
+    async stop(request) {
+        if (![request.sessionId, request.taskId, request.requestId].every(validId))
+            throw new Error('Invalid task stop identity');
+        const previous = this.requests.get(request.requestId);
+        if (previous) {
+            if (previous.sessionId !== request.sessionId || previous.taskId !== request.taskId)
+                throw new Error('Task stop request identity conflict');
+            return previous.receipt;
+        }
+        const profile = this.profile(), task = this.ledger.get(request.taskId);
+        if (!profile || !task || request.sessionId !== profile.rootSessionId ||
+            !task.origin.agentId || !task.origin.launchingToolUseId || task.taskType !== 'local_agent' ||
+            task.background !== true || !capabilitiesFor(profile, task, this.certifications, this.binding).stopActiveRun)
+            throw new Error('Task stop unavailable');
+        if (this.requests.size >= 4096)
+            throw new Error('Task stop receipt capacity exceeded');
+        const receipt = this.query.stopTask(request.taskId).then(() => ({ requestId: request.requestId, state: 'accepted' }), () => ({ requestId: request.requestId, state: 'unknown' }));
+        this.requests.set(request.requestId, { sessionId: request.sessionId, taskId: request.taskId, receipt });
+        return receipt;
+    }
+}

package/dist/workstation/qoderAdapter/taskLedger.js

@@ -0,0 +1,163 @@
+const identifier = (value) => typeof value === 'string' && value.length > 0 &&
+    Buffer.byteLength(value, 'utf8') <= 256 && !/[\x00-\x1f\x7f]/.test(value);
+const terminal = (state) => state === 'completed' || state === 'failed' || state === 'stopped';
+const defaultMaxTasks = 4096;
+const sameTask = (a, b) => a.state === b.state && a.live === b.live && a.stale === b.stale && a.taskType === b.taskType &&
+    a.background === b.background && JSON.stringify(a.origin) === JSON.stringify(b.origin);
+export class TaskLedger {
+    rootSessionId;
+    runtimeGeneration;
+    maxTasks;
+    tasks = new Map();
+    seen = new Set();
+    actors = new Map();
+    launchTasks = new Map();
+    conflicts = new Set();
+    notified = new Set();
+    failed = false;
+    constructor(rootSessionId, runtimeGeneration, maxTasks = defaultMaxTasks) {
+        this.rootSessionId = rootSessionId;
+        this.runtimeGeneration = runtimeGeneration;
+        this.maxTasks = maxTasks;
+        if (!identifier(rootSessionId) || !identifier(runtimeGeneration))
+            throw new Error('Invalid task ledger binding');
+        if (!Number.isInteger(maxTasks) || maxTasks < 1 || maxTasks > defaultMaxTasks)
+            throw new Error('Invalid task ledger capacity');
+    }
+    get(taskId) {
+        const task = this.tasks.get(taskId);
+        return task && { ...task, origin: { ...task.origin } };
+    }
+    all() { return [...this.tasks.keys()].map((id) => this.get(id)); }
+    get launchObservationCount() { return this.actors.size; }
+    get degraded() { return this.failed; }
+    markStale() {
+        for (const [id, task] of this.tasks)
+            this.tasks.set(id, { ...task, live: false, stale: true });
+        return this.all();
+    }
+    degrade() {
+        this.failed = true;
+        return this.markStale();
+    }
+    observeLaunch(toolUseId, agentId) {
+        if (this.failed || !identifier(toolUseId) || !identifier(agentId))
+            return [];
+        const prior = this.actors.get(toolUseId);
+        if (prior !== undefined && prior !== agentId)
+            this.actors.set(toolUseId, null);
+        else if (prior === undefined && this.actors.size < this.maxTasks)
+            this.actors.set(toolUseId, agentId);
+        const changed = [];
+        for (const [id, task] of this.tasks) {
+            if (task.origin.launchingToolUseId !== toolUseId)
+                continue;
+            const actor = this.actors.get(toolUseId);
+            const next = { ...task, origin: { ...task.origin,
+                    agentId: this.conflicts.has(id) ? undefined : actor ?? undefined },
+                stale: actor === null || this.conflicts.has(id) || task.stale };
+            this.tasks.set(id, next);
+            changed.push(next);
+        }
+        return changed;
+    }
+    ensure(taskId) {
+        if (!identifier(taskId))
+            return undefined;
+        const existing = this.tasks.get(taskId);
+        if (existing)
+            return existing;
+        if (this.tasks.size >= this.maxTasks) {
+            this.degrade();
+            return undefined;
+        }
+        const task = { origin: { rootSessionId: this.rootSessionId, runtimeGeneration: this.runtimeGeneration,
+                taskId }, state: 'unknown', live: false, stale: false };
+        this.tasks.set(taskId, task);
+        return task;
+    }
+    apply(message) {
+        if (this.failed || message.type !== 'system' || message.session_id !== this.rootSessionId ||
+            !identifier(message.uuid) || this.seen.has(message.uuid))
+            return [];
+        if (this.seen.size >= this.maxTasks * 4)
+            return this.degrade();
+        if (message.subtype === 'background_tasks_changed' && message.tasks.length > this.maxTasks)
+            return this.degrade();
+        if (message.subtype === 'background_tasks_changed') {
+            const added = new Set();
+            for (const entry of message.tasks) {
+                if (identifier(entry.task_id) && !this.tasks.has(entry.task_id))
+                    added.add(entry.task_id);
+                if (this.tasks.size + added.size > this.maxTasks)
+                    return this.degrade();
+            }
+        }
+        const previous = new Map(this.tasks);
+        this.seen.add(message.uuid);
+        if (message.subtype === 'background_tasks_changed') {
+            const current = new Map(message.tasks.filter((entry) => identifier(entry.task_id))
+                .map((entry) => [entry.task_id, entry]));
+            for (const [id, task] of this.tasks) {
+                if (!terminal(task.state) && task.background) {
+                    const next = { ...task, live: current.has(id),
+                        stale: current.has(id) ? this.conflicts.has(id) : task.stale };
+                    if (!sameTask(task, next))
+                        this.tasks.set(id, next);
+                }
+            }
+            for (const [id, entry] of current) {
+                const task = this.ensure(id);
+                if (task && !terminal(task.state)) {
+                    const next = { ...task, state: 'running', live: true,
+                        stale: this.conflicts.has(id), taskType: entry.task_type, background: true };
+                    if (!sameTask(task, next))
+                        this.tasks.set(id, next);
+                }
+            }
+        }
+        else if (message.subtype === 'task_started' || message.subtype === 'task_progress') {
+            const task = this.ensure(message.task_id);
+            if (task && !terminal(task.state)) {
+                const toolId = identifier(message.tool_use_id) ? message.tool_use_id : task.origin.launchingToolUseId;
+                if (toolId && !this.launchTasks.has(toolId) && this.launchTasks.size < this.maxTasks)
+                    this.launchTasks.set(toolId, message.task_id);
+                else if (toolId && this.launchTasks.get(toolId) !== message.task_id) {
+                    this.conflicts.add(message.task_id);
+                    const other = this.launchTasks.get(toolId);
+                    if (other) {
+                        this.conflicts.add(other);
+                        const previous = this.tasks.get(other);
+                        if (previous)
+                            this.tasks.set(other, { ...previous, stale: true,
+                                origin: { ...previous.origin, agentId: undefined } });
+                    }
+                }
+                const actor = toolId && this.actors.get(toolId);
+                this.tasks.set(message.task_id, { ...task, state: 'running', stale: this.conflicts.has(message.task_id),
+                    taskType: 'task_type' in message ? message.task_type : task.taskType,
+                    origin: { ...task.origin, launchingToolUseId: toolId,
+                        agentId: this.conflicts.has(message.task_id) ? undefined : actor ?? task.origin.agentId } });
+            }
+        }
+        else if (message.subtype === 'task_updated') {
+            const task = this.ensure(message.task_id);
+            if (task && !terminal(task.state)) {
+                const status = message.patch.status;
+                const state = status === 'killed' ? 'stopped' : status ?? task.state;
+                this.tasks.set(message.task_id, { ...task, state, live: terminal(state) ? false : task.live,
+                    stale: this.conflicts.has(message.task_id), background: message.patch.is_backgrounded ?? task.background });
+            }
+        }
+        else if (message.subtype === 'task_notification') {
+            const task = this.ensure(message.task_id);
+            if (task && (!this.notified.has(message.task_id) ||
+                (task.state === 'stopped' && message.status === 'completed'))) {
+                this.notified.add(message.task_id);
+                this.tasks.set(message.task_id, { ...task, state: message.status,
+                    live: false, stale: this.conflicts.has(message.task_id) });
+            }
+        }
+        return [...this.tasks].filter(([id, task]) => task !== previous.get(id)).map(([id]) => this.get(id));
+    }
+}

package/dist/workstation/qoderAdapter/types.js

@@ -0,0 +1 @@
+export {};

package/dist/workstation/qoderAdapter/usage.js

@@ -0,0 +1,37 @@
+export const QODER_CREDITS_LABEL = 'Qoder Credits（厂商报告）';
+const validCredits = (value) => typeof value === 'number' &&
+    Number.isFinite(value) && value >= 0;
+/** Qoder's report is cumulative. A missing/invalid report never erases a prior valid value. */
+export function applyCredits(previous, reported) {
+    if (validCredits(reported))
+        return reported;
+    return validCredits(previous) ? previous : undefined;
+}
+function reportedCredits(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return undefined;
+    const input = value;
+    for (const key of ['total_credits', 'totalCredits', 'credits'])
+        if (validCredits(input[key]))
+            return input[key];
+    return undefined;
+}
+/**
+ * Keeps vendor credits separate from ACP token/USD counters. Qoder's SDK does not
+ * provide equivalent token or USD values, so zero placeholders are intentionally omitted.
+ */
+export function normalizeQoderUsage(value, previousCredits) {
+    const input = value && typeof value === 'object' && !Array.isArray(value)
+        ? value : {};
+    const scope = input.cumulativeScope === 'unknown' ? 'unknown' : 'session';
+    const reported = reportedCredits(value);
+    if (scope === 'unknown') {
+        return { credits: undefined, creditsLabel: QODER_CREDITS_LABEL, creditsScope: scope,
+            inputTokens: undefined, outputTokens: undefined, costUsd: undefined,
+            ...(validCredits(previousCredits) ? { previousCredits } : {}) };
+    }
+    const credits = applyCredits(previousCredits, reported);
+    return { credits, creditsLabel: QODER_CREDITS_LABEL, creditsScope: scope,
+        inputTokens: undefined, outputTokens: undefined, costUsd: undefined,
+        ...(validCredits(previousCredits) ? { previousCredits } : {}) };
+}

package/dist/workstation/register.js

@@ -32,6 +32,10 @@ export async function registerWorkstation(server, clientName, token, ws) {
                 + `when the same machine re-registers after an axom-cli upgrade. Delete it under Settings → `
                 + 'Workstations, then run `axom workstation start` again.');
         }
+        if (res.status === 403) {
+            throw new UsageError('This credential is not authorized to register a workstation. '
+                + 'Run `axom auth` and select workstation, then try again.');
+        }
         throw new Error(`Registration failed: ${res.status} ${await res.text()}`);
     }
     const data = (await res.json());

package/dist/workstation/systemMetrics.js

@@ -100,6 +100,97 @@ async function defaultDarwinMemoryPressure() {
         return null;
     }
 }
+/**
+ * Parses `ioreg -r -d 1 -w 0 -c AGXAccelerator` output. Apple Silicon publishes live GPU
+ * utilization (`Device Utilization %`, a driver-side running average) and GPU-resident unified
+ * memory (`In use system memory`) in each accelerator's `PerformanceStatistics`, without any
+ * privileges. Intel Macs expose no `AGXAccelerator` class, so they parse to null.
+ */
+export function parseAppleAgxStats(output) {
+    const gpus = output.split('+-o ').slice(1).map((block, index) => {
+        const stats = /"PerformanceStatistics"\s*=\s*\{([^}]*)\}/.exec(block)?.[1];
+        if (stats === undefined)
+            return null;
+        const utilizationPercent = Number(/"Device Utilization %"\s*=\s*(\d+(?:\.\d+)?)/.exec(stats)?.[1]);
+        const memoryUsedBytes = Number(/"In use system memory"\s*=\s*(\d+)/.exec(stats)?.[1]);
+        return {
+            id: `apple:agx-${index}`,
+            name: /"model"\s*=\s*"([^"]+)"/.exec(block)?.[1] ?? 'Apple GPU',
+            utilization: Number.isFinite(utilizationPercent)
+                ? Math.max(0, Math.min(1, utilizationPercent / 100))
+                : null,
+            memoryTotalBytes: null,
+            memoryUsedBytes: Number.isFinite(memoryUsedBytes) && memoryUsedBytes >= 0 ? memoryUsedBytes : null,
+            coreCount: (() => {
+                const cores = Number(/"gpu-core-count"\s*=\s*(\d+)/.exec(block)?.[1]);
+                return Number.isFinite(cores) && cores > 0 ? cores : null;
+            })(),
+        };
+    }).filter((gpu) => gpu !== null);
+    return gpus.length > 0 ? gpus : null;
+}
+async function appleAgxGpuProbe() {
+    try {
+        const { stdout } = await execFileAsync('/usr/sbin/ioreg', ['-r', '-d', '1', '-w', '0', '-c', 'AGXAccelerator'], {
+            timeout: 2_000,
+            maxBuffer: 4 * 1024 * 1024,
+        });
+        return parseAppleAgxStats(stdout);
+    }
+    catch {
+        return null;
+    }
+}
+/** Parses `nvidia-smi --query-gpu=... --format=csv,noheader,nounits` output; `[N/A]` reads as null. */
+export function parseNvidiaSmiGpus(output) {
+    const mib = (field) => {
+        if (field === undefined)
+            return null;
+        const value = Number(field);
+        return Number.isFinite(value) && value >= 0 ? Math.round(value * 1024 * 1024) : null;
+    };
+    const gpus = output.split(/\r?\n/).map((line) => {
+        const fields = line.split(',').map((field) => field.trim());
+        if (fields.length < 6)
+            return null;
+        const [, uuid, name, utilizationField, totalField, usedField] = fields;
+        if (!/^GPU-/.test(uuid) || name.length === 0)
+            return null;
+        const utilizationPercent = Number(utilizationField);
+        return {
+            id: `nvidia:${uuid}`,
+            name,
+            utilization: Number.isFinite(utilizationPercent)
+                ? Math.max(0, Math.min(1, utilizationPercent / 100))
+                : null,
+            memoryTotalBytes: mib(totalField),
+            memoryUsedBytes: mib(usedField),
+            coreCount: null,
+        };
+    }).filter((gpu) => gpu !== null);
+    return gpus.length > 0 ? gpus : null;
+}
+async function nvidiaSmiGpuProbe() {
+    try {
+        const { stdout } = await execFileAsync('nvidia-smi', [
+            '--query-gpu=index,uuid,name,utilization.gpu,memory.total,memory.used',
+            '--format=csv,noheader,nounits',
+        ], { timeout: 3_000 });
+        return parseNvidiaSmiGpus(stdout);
+    }
+    catch {
+        // Absent binary, driver hiccup, or unsupported GPU -- all read as "no reading", never as failure.
+        return null;
+    }
+}
+async function defaultProbeGpus(platform) {
+    const [apple, nvidia] = await Promise.all([
+        platform === 'darwin' ? appleAgxGpuProbe() : Promise.resolve(null),
+        nvidiaSmiGpuProbe(),
+    ]);
+    const gpus = [...(apple ?? []), ...(nvidia ?? [])];
+    return gpus.length > 0 ? gpus : null;
+}
 /**
  * Low-overhead host sampler. CPU and memory are read only while a heartbeat is being built; storage
  * topology is discovered out of band and capacity reads use the cached representative paths.
@@ -114,6 +205,8 @@ export class SystemMetricsSampler {
     darwinMemoryRefreshInFlight = null;
     darwinMemoryAvailable = null;
     darwinMemoryPressure = null;
+    gpuRefreshInFlight = null;
+    gpus = null;
     constructor(workspaces, deps = {
         platform: process.platform,
         cpus: os.cpus,
@@ -126,12 +219,13 @@ export class SystemMetricsSampler {
         identifyStorage: (cwd, device) => defaultIdentifyStorage(process.platform, cwd, device),
         darwinAvailableMemory: defaultDarwinAvailableMemory,
         darwinMemoryPressure: defaultDarwinMemoryPressure,
+        probeGpus: () => defaultProbeGpus(process.platform),
     }) {
         this.workspaces = workspaces;
         this.deps = deps;
     }
     async start() {
-        await Promise.all([this.refreshTopology(), this.refreshDarwinMemory()]);
+        await Promise.all([this.refreshTopology(), this.refreshDarwinMemory(), this.refreshGpus()]);
         this.refreshTimer = setInterval(() => this.refreshTopologyInBackground(), STORAGE_TOPOLOGY_REFRESH_MS);
         this.refreshTimer.unref();
     }
@@ -143,6 +237,7 @@ export class SystemMetricsSampler {
     snapshot() {
         try {
             this.refreshDarwinMemoryInBackground();
+            this.refreshGpusInBackground();
             const cpus = this.deps.cpus();
             const currentCpu = cpuTotals(cpus);
             const previousCpu = this.previousCpu;
@@ -192,6 +287,7 @@ export class SystemMetricsSampler {
                 memoryTotalBytes,
                 memoryAvailableBytes,
                 storagePools: [...pools.values()],
+                gpus: this.gpus,
             };
         }
         catch {
@@ -218,6 +314,19 @@ export class SystemMetricsSampler {
                 this.darwinMemoryRefreshInFlight = null;
         });
     }
+    refreshGpusInBackground() {
+        if (this.gpuRefreshInFlight)
+            return;
+        const refresh = this.refreshGpus();
+        this.gpuRefreshInFlight = refresh;
+        void refresh.finally(() => {
+            if (this.gpuRefreshInFlight === refresh)
+                this.gpuRefreshInFlight = null;
+        });
+    }
+    async refreshGpus() {
+        this.gpus = await this.deps.probeGpus().catch(() => null);
+    }
     async refreshDarwinMemory() {
         if (this.deps.platform !== 'darwin')
             return;