@stratusagent/cli 0.7.0 → 0.8.0

package/dist/index.js

@@ -8,7 +8,7 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte
 };
 import { randomUUID } from 'node:crypto';
 import { spawn } from 'node:child_process';
-import { mkdtemp, readdir, readFile, rm, stat, writeFile } from 'node:fs/promises';
+import { mkdtemp, readdir, readFile, realpath, rm, stat, writeFile } from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
 import { createInterface } from 'node:readline';
@@ -17,8 +17,8 @@ import { createLocalCommandExecutor, } from '@stratusagent/executor-local';
 import { loadPlugins } from '@stratusagent/plugins';
 import { createFileCommandWhitelist, createPermissionPolicy, describeCommandScope, } from '@stratusagent/permissions';
 import { DEFAULT_ANTHROPIC_MODEL, redactAnthropicRawTurns, } from '@stratusagent/provider-anthropic';
-import { createRememberTool, defineAgent, formatSoul, generateAgentName, parseSoul, } from '@stratusagent/agents';
-import { agentsDirPath, claimSoulFile, collectAvailableModels as collectModels, createDemoTool, createFileMemoryStore, createRuntimeProvider, credentialsPath, defaultApiKeyEnvName, DEFAULT_ANTHROPIC_BASE_URL, DEFAULT_OPENAI_BASE_URL, DEFAULT_OPENAI_MODEL, DEFAULT_STRATUS_AGENT, discoverActiveConfig, globalConfigPath, loadChannelCredentials, loadCredentials, installSkillsFromDirectory, loadOperatorSkills, loadRosterSouls, skillsDirPath, listAgentSummaries, loadSoulFile, memoryFilePath, migrateLegacyMemory, parseProviderName, readNonEmptyString, readProcessEnv, logsDirPath, readWorkingDirectory, resolveAgentApprovals, DEFAULT_CONFIG_FILENAME, loadConfigFile, resolveConfigLocation, resolveRuntimeConfig as resolveStateRuntimeConfig, saveChannelCredentials, saveConfigFile, readTrustedConfigBlock, saveCredentials, servedRuntimes, verifyProviderKey, withLegacyDefaultMemories, workspacesDirPath, gatewayInfoPath, gatewayTokenPath, } from '@stratusagent/state';
+import { canonicalDestination, createForgetTool, createRecallTool, createRememberTool, defineAgent, describeCadence, describeSchedule, FORGET_TOOL_NAME, MEMORY_TOOL_NAME, formatSoul, generateAgentName, parseSoul, } from '@stratusagent/agents';
+import { agentsDirPath, claimSoulFile, collectAvailableModels as collectModels, createDemoTool, createFileMemoryStore, createRuntimeProvider, credentialsPath, defaultApiKeyEnvName, DEFAULT_ANTHROPIC_BASE_URL, DEFAULT_OPENAI_BASE_URL, DEFAULT_OPENAI_MODEL, DEFAULT_STRATUS_AGENT, discoverActiveConfig, globalConfigPath, loadChannelCredentials, loadCredentials, installSkillsFromDirectory, loadOperatorSkills, loadRosterSouls, skillsDirPath, listAgentSummaries, loadSoulFile, memoryFilePath, migrateLegacyMemory, parseProviderName, readNonEmptyString, readProcessEnv, resolveConfiguredSoul, logsDirPath, readWorkingDirectory, resolveAgentApprovals, DEFAULT_CONFIG_FILENAME, loadConfigFile, resolveConfigLocation, resolveRuntimeConfig as resolveStateRuntimeConfig, saveChannelCredentials, saveConfigFile, readTrustedConfigBlock, saveCredentials, servedRuntimes, verifyProviderKey, withLegacyDefaultMemories, workspacesDirPath, gatewayInfoPath, gatewayTokenPath, } from '@stratusagent/state';
 import { installService, readServiceStatus, servicePlatform, serviceUnitPath, startService, stopService, uninstallService, } from "./service.js";
 export { installService, launchdPlist, readServiceStatus, servicePlatform, serviceUnitPath, startService, stopService, systemdUnit, uninstallService, SERVICE_LABEL, } from "./service.js";
 import { createLogWriter, currentLogPosition, truncateRedirectLogs, formatLogRecord, readRecentRecords, tailLog, } from "./logs.js";
@@ -127,6 +127,8 @@ Usage:
   stratus skill add stratuslabs/skill-code-review
   stratus skill add ./my-skills --skill code-review --agent ava
   stratus skills
+  stratus schedules
+  stratus schedules cancel <id>
   stratus doctor
   stratus service install
   stratus service status
@@ -173,6 +175,12 @@ Commands:
                    --force replaces an already-installed id
   skills           List installed skills and which agents enable each
                    (also: stratus skill list)
+  schedules        List every schedule the fleet has set — cadence, prompt,
+                   pre-authorized destination, next firing — straight from the
+                   daemon's database (--format json). "stratus schedules
+                   cancel <id>" stops the next firing and revokes the
+                   destination that was approved with it
+                   (also: stratus schedule list / schedule cancel <id>)
   agent new        Create an agent identity (generates a human-ish name + avatar theme)
   agents           List your agents: who they are, where their souls live, what
                    they run on, what they remember (also: stratus agent list).
@@ -485,6 +493,48 @@ export const parseCommand = (argv, env = {}) => {
             ...(token ? { token } : {}),
         };
     }
+    if (command === 'schedules' || (command === 'schedule' && rest[0] === 'list') || (command === 'schedule' && rest[0] === 'cancel')) {
+        const schedulesRest = command === 'schedules' ? rest : rest.slice(1);
+        const action = (command === 'schedule' ? rest[0] : schedulesRest[0]) === 'cancel' ? 'cancel' : 'list';
+        const tokens = action === 'cancel' && command === 'schedules' ? schedulesRest.slice(1) : schedulesRest;
+        let format = 'text';
+        let scheduleId;
+        for (let index = 0; index < tokens.length; index += 1) {
+            const token = tokens[index];
+            if (!token || (action === 'list' && token === 'list' && index === 0)) {
+                continue;
+            }
+            if (token === '--help' || token === '-h') {
+                return { command: 'help' };
+            }
+            if (token === '--format') {
+                const value = readOptionValue(tokens, index, '--format');
+                if (value !== 'text' && value !== 'json') {
+                    throw new Error(`Unsupported format: ${value}`);
+                }
+                format = value;
+                index += 1;
+                continue;
+            }
+            if (token.startsWith('--')) {
+                throw new Error(`Unknown option: ${token}`);
+            }
+            if (action === 'cancel' && scheduleId === undefined) {
+                scheduleId = token;
+                continue;
+            }
+            throw new Error(`Unexpected argument: ${token}. Try: stratus schedules, stratus schedules cancel <id>`);
+        }
+        if (action === 'cancel' && !scheduleId) {
+            throw new Error('schedules cancel needs the schedule id: stratus schedules cancel <id>.');
+        }
+        return {
+            command: 'schedules',
+            action,
+            ...(scheduleId ? { scheduleId } : {}),
+            format,
+        };
+    }
     if (command === 'doctor') {
         let format = 'text';
         let configPath;
@@ -895,7 +945,7 @@ export const formatEvent = (event) => {
  * granted permission leaves no trace whatsoever. Still no tool input: what
  * was asked is here, what it was asked with is not.
  */
-const eventDetail = (event) => {
+export const eventDetail = (event) => {
     switch (event.type) {
         case 'session.updated':
             return { status: event.status };
@@ -904,8 +954,19 @@ const eventDetail = (event) => {
         case 'tool.called':
         case 'tool.denied':
             return { tool: event.call.toolName };
-        case 'tool.completed':
-            return { tool: event.result.toolName, ok: event.result.ok };
+        case 'tool.completed': {
+            // A memory write or retirement names the entry it touched — the id
+            // is a reference, not content, and "when did the agent learn/drop
+            // this" is unanswerable later without it. The fact itself stays out
+            // of the trace, like every other tool input and output.
+            const output = event.result.output;
+            const entry = (event.result.toolName === MEMORY_TOOL_NAME || event.result.toolName === FORGET_TOOL_NAME)
+                && event.result.ok && typeof output === 'object' && output !== null && !Array.isArray(output)
+                && typeof output.id === 'string'
+                ? output.id
+                : undefined;
+            return { tool: event.result.toolName, ok: event.result.ok, ...(entry !== undefined ? { entry } : {}) };
+        }
         case 'tool.approval-requested':
             return { tool: event.call.toolName, risk: event.risk, requestId: event.requestId };
         case 'tool.approval-resolved':
@@ -1019,6 +1080,8 @@ const createAgentRuntime = async (streams, options) => {
     const tools = new ToolRegistry();
     tools.register(createDemoTool());
     tools.register(createRememberTool(memory));
+    tools.register(createRecallTool(memory));
+    tools.register(createForgetTool(memory));
     // The same skills the daemon would serve, from the same directory, for
     // the same reason the plugins below match: a skill that routes in
     // `stratus run` routes in `stratus serve`, and one that is broken is
@@ -1769,11 +1832,17 @@ const verifySlackAppToken = async (token, fetchImpl) => {
 // package being installed.
 const SLACK_BOT_SCOPES = [
     'app_mentions:read',
+    // The conversations read family backs outbound destination validation
+    // (conversations.info): whether a channel a schedule wants to report to
+    // exists, and whether this app is a member of it.
+    'channels:read',
     'chat:write',
     'files:write',
+    'groups:read',
     'im:history',
     'im:read',
     'im:write',
+    'mpim:read',
     'users:read',
 ];
 const SLACK_BOT_EVENTS = ['app_mention', 'message.im'];
@@ -1803,7 +1872,8 @@ export const slackAppManifest = (agentName) => JSON.stringify({
 const DEFAULT_SOUL_STARTER = [
     'You are a helpful, warm generalist. Answer first, explain second, and',
     'keep replies short unless the question genuinely needs depth. Use',
-    'memory.remember for durable facts about the people you work with.',
+    'memory.remember for durable facts about the people you work with, and',
+    'memory.recall to look up what you know when a conversation calls for it.',
 ].join('\n');
 export const runSetup = async (command, streams, env = {}) => {
     const cwd = readWorkingDirectory(env);
@@ -3736,7 +3806,11 @@ const resolveSkillSource = async (source, env) => {
     const localPath = path.resolve(readWorkingDirectory(env), source);
     try {
         if ((await stat(localPath)).isDirectory()) {
-            return { kind: 'local', directory: localPath };
+            // The real directory, not the path as typed: a source that is
+            // itself a symlink would otherwise be copied as that link — an
+            // installed entry pointing back at the source tree, which the
+            // loader ignores as not-a-directory.
+            return { kind: 'local', directory: await realpath(localPath) };
         }
     }
     catch {
@@ -3750,8 +3824,30 @@ const resolveSkillSource = async (source, env) => {
     }
     throw new Error(`Cannot read ${JSON.stringify(source)} as a skill source. Pass a GitHub owner/repo, a git URL, or a local path.`);
 };
+/**
+ * A source URL safe to print: userinfo stripped. A token travels in exactly
+ * this position (`https://user:token@host/repo.git`), stdout is commonly
+ * retained in CI logs, and git's own stderr already redacts — only the
+ * unredacted URL is handed to git itself.
+ */
+const redactedSourceUrl = (url) => {
+    try {
+        const parsed = new URL(url);
+        if (parsed.username || parsed.password) {
+            parsed.username = '***';
+            parsed.password = '';
+        }
+        return parsed.toString();
+    }
+    catch {
+        // scp-style (git@host:path) or anything else URL() refuses: keep the
+        // shape, hide whatever sits before the @.
+        return url.replace(/^[^@/]+@/, '***@');
+    }
+};
 /** Shallow-clone a skills source. Git owns every transport we would otherwise re-implement. */
 const cloneSkillSource = async (url, destination) => {
+    const display = redactedSourceUrl(url);
     await new Promise((resolve, reject) => {
         const child = spawn('git', ['clone', '--depth', '1', '--quiet', url, destination], {
             stdio: ['ignore', 'ignore', 'pipe'],
@@ -3761,18 +3857,54 @@ const cloneSkillSource = async (url, destination) => {
             stderr += String(chunk);
         });
         child.on('error', (error) => {
-            reject(new Error(`Could not run git to fetch ${url}: ${error.message}`));
+            reject(new Error(`Could not run git to fetch ${display}: ${error.message}`));
         });
         child.on('close', (code) => {
             if (code === 0) {
                 resolve();
             }
             else {
-                reject(new Error(`git clone failed for ${url}: ${stderr.trim() || `exit code ${code}`}`));
+                // git redacts credentials in its own messages; the URL we echo is
+                // ours to redact.
+                reject(new Error(`git clone failed for ${display}: ${stderr.trim() || `exit code ${code}`}`));
             }
         });
     });
 };
+/**
+ * The souls skill enablement is judged against: the agents directory plus
+ * the configured default soul (config `soul:` / STRATUS_SOUL), which may
+ * live outside it and is served all the same. The daemon's roster and
+ * `stratus agents` both include it, so `skill add --agent` and `stratus
+ * skills` must not answer from a narrower set.
+ */
+const rosterSoulsWithConfigured = async (env, warn) => {
+    const entries = await loadRosterSouls(env, warn);
+    let complete = true;
+    try {
+        const configured = await resolveConfiguredSoul({}, env);
+        if (configured) {
+            const entry = { soul: configured.soul, path: configured.path };
+            const clash = entries.findIndex((candidate) => candidate.soul.agent.id === configured.soul.agent.id);
+            // Replaced, not skipped: a roster file claiming the configured
+            // soul's id is the one the gateway stops serving — both commands
+            // must answer for the soul a dispatch actually runs.
+            if (clash >= 0) {
+                entries[clash] = entry;
+            }
+            else {
+                entries.push(entry);
+            }
+        }
+    }
+    catch (error) {
+        // The configured agent's allowlist was not read, so the set is not
+        // the roster — callers making enablement claims must withhold them.
+        complete = false;
+        warn(`could not read the configured soul: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    return { entries, complete };
+};
 export const runSkillAdd = async (command, streams, env = {}) => {
     const resolved = await resolveSkillSource(command.source, env);
     let sourceDir;
@@ -3783,7 +3915,7 @@ export const runSkillAdd = async (command, streams, env = {}) => {
     else {
         const scratch = await mkdtemp(path.join(os.tmpdir(), 'stratus-skill-add-'));
         cleanup = () => rm(scratch, { recursive: true, force: true });
-        writeLine(streams.stdout, `Fetching ${resolved.url} …`);
+        writeLine(streams.stdout, `Fetching ${redactedSourceUrl(resolved.url)} …`);
         try {
             await cloneSkillSource(resolved.url, scratch);
         }
@@ -3794,17 +3926,30 @@ export const runSkillAdd = async (command, streams, env = {}) => {
         sourceDir = scratch;
     }
     try {
+        // For a cloned source the temp directory's random basename must not
+        // name a root-level skill — the repository's own name is what a
+        // nameless root SKILL.md installs under.
+        const rootId = resolved.kind === 'git'
+            ? path.basename(new URL(resolved.url.replace(/^git@([^:]+):/, 'ssh://git@$1/')).pathname, '.git')
+            : undefined;
         const result = await installSkillsFromDirectory(env, sourceDir, {
             ...(command.skillIds ? { only: command.skillIds } : {}),
             ...(command.force ? { force: true } : {}),
+            ...(rootId !== undefined && rootId.length > 0 ? { rootId } : {}),
         });
         for (const skill of result.installed) {
             writeLine(streams.stdout, `installed ${skill.id} — ${skill.description}`);
         }
+        // Present already is a no-op, not a failure — and exactly what the
+        // "rerun with --agent" hint below produces, so these stay eligible
+        // for the enablement step.
+        for (const skill of result.alreadyInstalled) {
+            writeLine(streams.stdout, `already installed ${skill.id} — ${skill.description}`);
+        }
         for (const skip of result.skipped) {
             writeLine(streams.stderr, `Warning: skipped ${skip.id}: ${skip.reason}`);
         }
-        if (result.installed.length === 0) {
+        if (result.installed.length === 0 && result.alreadyInstalled.length === 0) {
             writeLine(streams.stderr, result.skipped.length > 0
                 ? 'Error: nothing was installed.'
                 : `Error: no skills found in ${command.source}. A skill is a directory with a SKILL.md.`);
@@ -3813,7 +3958,7 @@ export const runSkillAdd = async (command, streams, env = {}) => {
         // Installed is not enabled: a soul opts in through its skills:
         // allowlist, and that stays true when the install came through a
         // command. --agent is the explicit way to say both at once.
-        const ids = result.installed.map((skill) => skill.id);
+        const ids = [...result.installed, ...result.alreadyInstalled].map((skill) => skill.id);
         if (command.agentId === undefined) {
             writeLine(streams.stdout);
             writeLine(streams.stdout, 'Installed, not yet enabled. Add to an agent\'s soul frontmatter:');
@@ -3824,10 +3969,10 @@ export const runSkillAdd = async (command, streams, env = {}) => {
             writeLine(streams.stdout, `(or rerun with --agent <id>, or list them: stratus skills)`);
             return 0;
         }
-        const roster = await loadRosterSouls(env, (line) => writeLine(streams.stderr, `Warning: ${line}`));
+        const { entries: roster } = await rosterSoulsWithConfigured(env, (line) => writeLine(streams.stderr, `Warning: ${line}`));
         const entry = roster.find((candidate) => candidate.soul.agent.id === command.agentId);
         if (!entry) {
-            writeLine(streams.stderr, `Error: no agent with id ${command.agentId} in ${agentsDirPath(env)}. The skills are installed; enable them by editing a soul.`);
+            writeLine(streams.stderr, `Error: no agent with id ${command.agentId} in ${agentsDirPath(env)} or the configured soul. The skills are installed; enable them by editing a soul.`);
             return 1;
         }
         const existing = entry.soul.agent.skills ?? [];
@@ -3850,6 +3995,53 @@ export const runSkillAdd = async (command, streams, env = {}) => {
         await cleanup?.();
     }
 };
+/**
+ * List and cancel what the fleet has scheduled — against the daemon's own
+ * database, the way `stratus logs` reads the daemon's own log. WAL makes a
+ * second process on the file routine; a running daemon re-reads due rows
+ * every tick and the destination grant on every send, so a cancel from
+ * here takes effect without asking it anything.
+ */
+export const runSchedules = async (command, streams, env = {}) => {
+    // Lazy like the serve path: node:sqlite loads only for the command that
+    // needs it.
+    const { SqliteScheduleStore, defaultSessionDbPath } = await import('@stratusagent/gateway');
+    const store = new SqliteScheduleStore(defaultSessionDbPath(env));
+    try {
+        if (command.action === 'cancel') {
+            const id = command.scheduleId ?? '';
+            const record = store.get(id);
+            if (!record || !store.delete(id)) {
+                writeLine(streams.stderr, `No schedule with id ${id}. \`stratus schedules\` lists what exists.`);
+                return 1;
+            }
+            writeLine(streams.stdout, `Cancelled ${id} (${record.agentId}, ${describeCadence(record.cadence)}).`);
+            if (record.destination) {
+                writeLine(streams.stdout, `Its pre-authorized destination ${canonicalDestination(record.destination)} is revoked with it.`);
+            }
+            return 0;
+        }
+        const schedules = store.list();
+        if (command.format === 'json') {
+            writeLine(streams.stdout, JSON.stringify({ schedules: schedules.map(describeSchedule) }, null, 2));
+            return 0;
+        }
+        if (schedules.length === 0) {
+            writeLine(streams.stdout, 'No schedules set. An agent sets one with the schedule.every / schedule.at tools.');
+            return 0;
+        }
+        for (const record of schedules) {
+            const destination = record.destination ? `  →  ${canonicalDestination(record.destination)}` : '';
+            writeLine(streams.stdout, `${record.id}  [${record.agentId}]  ${describeCadence(record.cadence)}${destination}`);
+            writeLine(streams.stdout, `  next: ${record.nextFireAt ?? '(spent — awaiting cleanup)'}${record.lastFiredAt ? `   last: ${record.lastFiredAt}` : ''}`);
+            writeLine(streams.stdout, `  prompt: ${record.prompt}`);
+        }
+        return 0;
+    }
+    finally {
+        store.close();
+    }
+};
 export const runSkills = async (streams, env = {}) => {
     const registry = new SkillRegistry();
     const skills = await loadOperatorSkills(env, registry, (line) => {
@@ -3864,17 +4056,34 @@ export const runSkills = async (streams, env = {}) => {
     // follows "what is installed" — read from the same roster a dispatch
     // serves. Plugin-contributed skills are the daemon's to list
     // (/catalog/tools); this command reads the operator directory.
-    const roster = await loadRosterSouls(env, () => { }).catch(() => []);
+    //
+    // A roster that will not load (a duplicate agent id, deliberately
+    // fatal) is unreadable enablement, not empty enablement: say so and
+    // withhold the claim rather than reporting every skill unused.
+    let roster = [];
+    let rosterUnreadable = false;
+    try {
+        const resolved = await rosterSoulsWithConfigured(env, (line) => writeLine(streams.stderr, `Warning: ${line}`));
+        roster = resolved.entries;
+        rosterUnreadable = !resolved.complete;
+    }
+    catch (error) {
+        rosterUnreadable = true;
+        writeLine(streams.stderr, `Warning: cannot say who enables what — the roster did not load: ${error instanceof Error ? error.message : String(error)}`);
+    }
     for (const skill of skills) {
-        const enabledBy = roster
-            .filter((entry) => {
-            const allowlist = entry.soul.agent.skills;
-            return allowlist !== undefined
-                && allowlist.length > 0
-                && matchesSkillAllowlist(skill.id, allowlist);
-        })
-            .map((entry) => entry.soul.agent.name);
-        const suffix = enabledBy.length > 0 ? ` — enabled by ${enabledBy.join(', ')}` : ' — enabled by nobody yet';
+        let suffix = '';
+        if (!rosterUnreadable) {
+            const enabledBy = roster
+                .filter((entry) => {
+                const allowlist = entry.soul.agent.skills;
+                return allowlist !== undefined
+                    && allowlist.length > 0
+                    && matchesSkillAllowlist(skill.id, allowlist);
+            })
+                .map((entry) => entry.soul.agent.name);
+            suffix = enabledBy.length > 0 ? ` — enabled by ${enabledBy.join(', ')}` : ' — enabled by nobody yet';
+        }
         writeLine(streams.stdout, `${skill.id.padEnd(24)}${skill.description}${suffix}`);
     }
     return 0;
@@ -4450,9 +4659,14 @@ export const runServe = async (command, streams, env = {}) => {
             log(`${agentId}: "${describeCommandScope(scope)}" now runs without asking`);
         },
     };
-    const approvals = (transport) => createPermissionPolicy(approvalMode === 'remote'
-        ? { mode: 'remote', request: transport.request, onDecision, commands }
-        : { mode: 'headless', onDecision, commands });
+    const approvals = (transport) => createPermissionPolicy(
+    // The destination scope rides along in BOTH modes — it is what lets a
+    // scheduled turn report to the channel a human approved with the
+    // schedule, and headless (where every other gated call is refused) is
+    // exactly the deployment it exists for.
+    approvalMode === 'remote'
+        ? { mode: 'remote', request: transport.request, onDecision, commands, destinations: transport.destinations }
+        : { mode: 'headless', onDecision, commands, destinations: transport.destinations });
     if (approvalMode === 'remote') {
         // Only agents whose channel actually came up can be asked: tokens on
         // disk with the Slack package missing means nothing renders the
@@ -4643,6 +4857,9 @@ export const runCli = async ({ argv, streams = process, env = {} }) => {
         if (command.command === 'skills') {
             return await runSkills(streams, resolvedEnv);
         }
+        if (command.command === 'schedules') {
+            return await runSchedules(command, streams, resolvedEnv);
+        }
         if (command.command === 'doctor') {
             return await runDoctor(command, streams, resolvedEnv);
         }