@ocis/myagent-cli 0.2.0

package/dist/approval/policy.d.ts

@@ -0,0 +1,81 @@
+import type { ApprovalRequest } from "../tools/types.js";
+import type { AgentMode } from "../agent/modes.js";
+export type ApprovalMode = "ask" | "auto";
+export type ApprovalOutcome = "approved" | "denied" | "timeout" | "cancelled";
+export interface ApprovalPrompt {
+    (request: ApprovalRequest, signal: AbortSignal): Promise<ApprovalOutcome>;
+}
+/** Fixed approval deadline — never reset by keypresses. */
+export declare const APPROVAL_TIMEOUT_MS: number;
+export declare class ApprovalPolicy {
+    private mode;
+    private readonly prompt;
+    private readonly getAgentMode;
+    /**
+     * Text handed to the model when a mutating tool is denied. Headless mode
+     * overrides it: with no one to ask, "the user declined" would be false.
+     */
+    readonly deniedMessage: string;
+    /**
+     * Text handed to the model when the approval deadline passes. The agent
+     * must stop waiting on the user and say so instead of hanging.
+     */
+    readonly timeoutMessage: string;
+    /** Injectable for tests; the deadline is fixed everywhere else. */
+    private readonly timeoutMs;
+    /**
+     * Every approval not yet settled — the one being shown plus the ones queued
+     * behind it. Concurrency is real (a round's read-only calls run in parallel
+     * and outside-workspace reads prompt; a second tool round can start while an
+     * earlier one waits), so a single slot would lose an earlier prompt's cancel
+     * and leave it hanging until the deadline.
+     */
+    private pending;
+    /**
+     * Serializes the prompts themselves: the UI shows ONE approval card, so a
+     * second concurrent prompt would overwrite the first's resolver and strand
+     * it. Each waiter releases the next in its `finally`.
+     */
+    private queue;
+    /** Approvals in flight (prompting or queued) — 0 means the card is free. */
+    private inFlight;
+    constructor(mode: ApprovalMode, prompt: ApprovalPrompt, getAgentMode: () => AgentMode, 
+    /**
+     * Text handed to the model when a mutating tool is denied. Headless mode
+     * overrides it: with no one to ask, "the user declined" would be false.
+     */
+    deniedMessage?: string, 
+    /**
+     * Text handed to the model when the approval deadline passes. The agent
+     * must stop waiting on the user and say so instead of hanging.
+     */
+    timeoutMessage?: string, 
+    /** Injectable for tests; the deadline is fixed everywhere else. */
+    timeoutMs?: number);
+    get current(): ApprovalMode;
+    setMode(mode: ApprovalMode): void;
+    toggle(): ApprovalMode;
+    /** Decide whether a tool may run. Outside-workspace calls always prompt. */
+    approve(request: ApprovalRequest): Promise<ApprovalOutcome>;
+    /**
+     * Cancel pending approvals — the one on screen and any queued behind it.
+     * With `toolCallIds`, only the ones about those calls (a release of another
+     * call in the same round must not cancel this one). Called by the runner
+     * when the server releases a call or the run is stopped — a released call
+     * must never run.
+     */
+    cancelPending(toolCallIds?: string[]): void;
+    /**
+     * Race the prompt against the fixed deadline. The deadline is enforced HERE
+     * (single source of truth); the signal lets the UI dismiss its card when
+     * the deadline passes or the approval is cancelled. The deadline promise
+     * settles before the abort fires, so a prompt that also resolves on abort
+     * can never beat the policy's outcome.
+     *
+     * The deadline runs from THIS call, not from the moment the card appears:
+     * a queued approval that waits out the deadline behind another one settles
+     * as `timeout` without ever prompting — the agent must not be left waiting
+     * on a card the user will never see.
+     */
+    private promptWithDeadline;
+}

package/dist/approval/policy.js

@@ -0,0 +1,157 @@
+// ---------------------------------------------------------------------------
+// Approval policy.
+//
+// `auto` (the default) runs workspace work unattended, but still prompts when a
+// call reaches outside the workspace. `ask` prompts before every mutating tool
+// (and for outside reads too). The mode is per session, toggled with /edit or
+// Shift+Tab; read-only workspace tools never prompt. Plan mode is enforced at
+// execution time in AgentRunner (mutating tools refuse); this layer's plan
+// check is the second line of defense in case a call ever reaches approval.
+//
+// The prompt resolves to a 4-state outcome rather than a boolean: `timeout`
+// (the fixed 10-minute deadline passed — the agent gets an error result so it
+// stops waiting) and `cancelled` (the server released the call, or the run was
+// stopped — the tool never runs and nothing is submitted) must be
+// distinguishable from a plain deny. Both the deadline and the cancellation are
+// enforced HERE: every prompt implementation gets them for free, and its
+// AbortSignal is the dismissal hook for whatever UI is showing.
+// ---------------------------------------------------------------------------
+import { isReadOnlyTool } from "../agent/modes.js";
+/** Fixed approval deadline — never reset by keypresses. */
+export const APPROVAL_TIMEOUT_MS = 10 * 60 * 1000;
+export class ApprovalPolicy {
+    mode;
+    prompt;
+    getAgentMode;
+    deniedMessage;
+    timeoutMessage;
+    timeoutMs;
+    /**
+     * Every approval not yet settled — the one being shown plus the ones queued
+     * behind it. Concurrency is real (a round's read-only calls run in parallel
+     * and outside-workspace reads prompt; a second tool round can start while an
+     * earlier one waits), so a single slot would lose an earlier prompt's cancel
+     * and leave it hanging until the deadline.
+     */
+    pending = new Set();
+    /**
+     * Serializes the prompts themselves: the UI shows ONE approval card, so a
+     * second concurrent prompt would overwrite the first's resolver and strand
+     * it. Each waiter releases the next in its `finally`.
+     */
+    queue = Promise.resolve();
+    /** Approvals in flight (prompting or queued) — 0 means the card is free. */
+    inFlight = 0;
+    constructor(mode, prompt, getAgentMode, 
+    /**
+     * Text handed to the model when a mutating tool is denied. Headless mode
+     * overrides it: with no one to ask, "the user declined" would be false.
+     */
+    deniedMessage = "The user declined to run this action.", 
+    /**
+     * Text handed to the model when the approval deadline passes. The agent
+     * must stop waiting on the user and say so instead of hanging.
+     */
+    timeoutMessage = "Error: request approval timeout — the user did not respond within 10 minutes. Stop and wait for the user.", 
+    /** Injectable for tests; the deadline is fixed everywhere else. */
+    timeoutMs = APPROVAL_TIMEOUT_MS) {
+        this.mode = mode;
+        this.prompt = prompt;
+        this.getAgentMode = getAgentMode;
+        this.deniedMessage = deniedMessage;
+        this.timeoutMessage = timeoutMessage;
+        this.timeoutMs = timeoutMs;
+    }
+    get current() {
+        return this.mode;
+    }
+    setMode(mode) {
+        this.mode = mode;
+    }
+    toggle() {
+        this.mode = this.mode === "auto" ? "ask" : "auto";
+        return this.mode;
+    }
+    /** Decide whether a tool may run. Outside-workspace calls always prompt. */
+    async approve(request) {
+        // Plan mode keys off the per-CALL mutation verdict when the caller has it
+        // (a tool whose arguments decide it — transfer get vs put/list); the
+        // name-based read-only list is the fallback for callers that don't.
+        const sideEffecting = request.mutating ?? !isReadOnlyTool(request.tool);
+        if (sideEffecting && this.getAgentMode() === "plan") {
+            return "denied";
+        }
+        if (request.outsideWorkspace)
+            return this.promptWithDeadline(request);
+        if (!sideEffecting || this.mode === "auto")
+            return "approved";
+        return this.promptWithDeadline(request);
+    }
+    /**
+     * Cancel pending approvals — the one on screen and any queued behind it.
+     * With `toolCallIds`, only the ones about those calls (a release of another
+     * call in the same round must not cancel this one). Called by the runner
+     * when the server releases a call or the run is stopped — a released call
+     * must never run.
+     */
+    cancelPending(toolCallIds) {
+        for (const pending of [...this.pending]) {
+            // With a filter, only entries about those calls cancel. An entry with
+            // no callId cannot be matched, so a release of another call must leave
+            // it alone (the unfiltered form cancels everything).
+            if (toolCallIds && (pending.callId === undefined || !toolCallIds.includes(pending.callId)))
+                continue;
+            pending.cancel();
+        }
+    }
+    /**
+     * Race the prompt against the fixed deadline. The deadline is enforced HERE
+     * (single source of truth); the signal lets the UI dismiss its card when
+     * the deadline passes or the approval is cancelled. The deadline promise
+     * settles before the abort fires, so a prompt that also resolves on abort
+     * can never beat the policy's outcome.
+     *
+     * The deadline runs from THIS call, not from the moment the card appears:
+     * a queued approval that waits out the deadline behind another one settles
+     * as `timeout` without ever prompting — the agent must not be left waiting
+     * on a card the user will never see.
+     */
+    async promptWithDeadline(request) {
+        const controller = new AbortController();
+        const deadline = Promise.withResolvers();
+        let settled = false;
+        const finish = (outcome) => {
+            if (settled)
+                return;
+            settled = true;
+            deadline.resolve(outcome);
+            controller.abort();
+        };
+        const timer = setTimeout(() => finish("timeout"), this.timeoutMs);
+        timer.unref?.();
+        const entry = { callId: request.callId, cancel: () => finish("cancelled") };
+        this.pending.add(entry);
+        // Take a slot in the prompt queue before awaiting the previous one, so
+        // arrival order is preserved. A free card (nothing in flight) is shown
+        // WITHOUT awaiting: the common single-approval case must not cost a tick.
+        const previous = this.queue;
+        const released = Promise.withResolvers();
+        const wait = this.inFlight > 0;
+        this.inFlight++;
+        this.queue = released.promise;
+        try {
+            // A cancel/timeout while queued settles immediately — no card, no wait.
+            if (wait)
+                await Promise.race([previous.catch(() => { }), deadline.promise]);
+            if (settled)
+                return await deadline.promise;
+            return await Promise.race([this.prompt(request, controller.signal), deadline.promise]);
+        }
+        finally {
+            this.pending.delete(entry);
+            this.inFlight--;
+            clearTimeout(timer);
+            released.resolve();
+        }
+    }
+}

package/dist/config.d.ts

@@ -0,0 +1,49 @@
+export type ApprovalMode = "ask" | "auto";
+export interface StoredConfig {
+    /** MyAgent backend base URL, e.g. https://agent.example.com */
+    baseUrl: string;
+    /** Integration ID from the MyAgent Integrations page. */
+    integrationId: string;
+    /** Integration API key (iak_...). */
+    apiKey: string;
+    /** Default approval mode for new sessions ("auto" = run tools unattended). */
+    approvalDefault: ApprovalMode;
+    /** @deprecated superseded by approvalDefault; kept for config compatibility. */
+    autoApprove?: boolean;
+}
+export declare const EMPTY_CONFIG: StoredConfig;
+export declare function configDir(): string;
+export declare function configPath(): string;
+/** Local session index (cwd → known threads). Not secret; 0644. */
+export declare function sessionsPath(): string;
+/** Global context file, loaded before project AGENTS.md/CLAUDE.md files. */
+export declare function globalContextPath(): string;
+/**
+ * One-time migration: if the config dir from a previous name (myagent-cli)
+ * exists and the current one does not, rename it so existing credentials and
+ * skills carry over. Idempotent and best-effort.
+ */
+export declare function migrateLegacyConfigDir(): Promise<void>;
+export declare function loadConfig(): Promise<StoredConfig>;
+export declare function saveConfig(config: StoredConfig): Promise<void>;
+/**
+ * Resolve effective credentials from file config, environment, and flags.
+ * Later sources win. Returns the merged config plus whether it's usable.
+ */
+export declare function resolveConfig(stored: StoredConfig, flags: Partial<StoredConfig>): StoredConfig;
+export declare function isConfigured(config: StoredConfig): boolean;
+/**
+ * Split a combined API base URL (`<host>/integrations/<id>`) into its parts.
+ * The Integrations page shows this single URL, so pasting it anywhere a base
+ * URL is accepted (wizard, --base-url, MYAGENT_BASE_URL, config file) must
+ * work. A trailing path is tolerated (old clipboards carry full endpoint URLs
+ * like `.../integrations/<id>/v1/chat/completions` — same rule as the
+ * extension's parseEndpointUrl); a URL without `/integrations/<id>` is
+ * returned unchanged.
+ */
+export declare function splitIntegrationUrl(url: string): {
+    baseUrl: string;
+    integrationId?: string;
+};
+/** The combined API base URL shown in the UI, for display/copy. */
+export declare function combinedIntegrationUrl(config: StoredConfig): string;

package/dist/config.js

@@ -0,0 +1,156 @@
+// -------------------------------------------------------------------
+// Persistent CLI configuration (credentials + preferences).
+//
+// Stored at $XDG_CONFIG_HOME/myagent/config.json (defaults to
+// ~/.config/myagent/config.json), with 0600 perms since it holds an
+// API key. Runtime values resolve in order: CLI flags > env vars > file.
+// -------------------------------------------------------------------
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { mkdir, chmod, rename, stat } from "node:fs/promises";
+import { fileExists, readJsonFile, writeFile } from "./runtime.js";
+export const EMPTY_CONFIG = {
+    baseUrl: "",
+    integrationId: "",
+    apiKey: "",
+    approvalDefault: "auto",
+};
+function configBase() {
+    return process.env.XDG_CONFIG_HOME?.trim() || join(homedir(), ".config");
+}
+export function configDir() {
+    return join(configBase(), "myagent");
+}
+export function configPath() {
+    return join(configDir(), "config.json");
+}
+/** Local session index (cwd → known threads). Not secret; 0644. */
+export function sessionsPath() {
+    return join(configDir(), "sessions.json");
+}
+/** Global context file, loaded before project AGENTS.md/CLAUDE.md files. */
+export function globalContextPath() {
+    return join(configDir(), "AGENTS.md");
+}
+/**
+ * One-time migration: if the config dir from a previous name (myagent-cli)
+ * exists and the current one does not, rename it so existing credentials and
+ * skills carry over. Idempotent and best-effort.
+ */
+export async function migrateLegacyConfigDir() {
+    const current = configDir();
+    const legacy = join(configBase(), "myagent-cli");
+    if (current === legacy)
+        return;
+    try {
+        const hasCurrent = await stat(current).then(() => true).catch(() => false);
+        const hasLegacy = await stat(legacy).then(() => true).catch(() => false);
+        if (!hasCurrent && hasLegacy)
+            await rename(legacy, current);
+    }
+    catch {
+        /* best-effort — a failed migration just means the user reconfigures */
+    }
+}
+export async function loadConfig() {
+    try {
+        const path = configPath();
+        if (!(await fileExists(path)))
+            return { ...EMPTY_CONFIG };
+        const data = await readJsonFile(path);
+        const merged = { ...EMPTY_CONFIG, ...data };
+        // Legacy field: autoApprove:false used to mean "ask" — honour it once.
+        if (data.approvalDefault === undefined && data.autoApprove === false) {
+            merged.approvalDefault = "ask";
+        }
+        // Fail CLOSED: only an explicit "auto" means auto — corrupted files,
+        // typos, or future unknown values must fall back to asking, never to
+        // unattended tool execution.
+        merged.approvalDefault = merged.approvalDefault === "auto" ? "auto" : "ask";
+        // A stored combined URL (`<host>/integrations/<id>`) is self-contained —
+        // its id is authoritative for this source.
+        applyBaseUrl(merged, merged.baseUrl);
+        return merged;
+    }
+    catch {
+        // Corrupt or unreadable config — start from empty rather than crashing.
+        return { ...EMPTY_CONFIG };
+    }
+}
+export async function saveConfig(config) {
+    await mkdir(configDir(), { recursive: true });
+    // Write to a temp file then rename atomically so a mid-write crash or signal
+    // never leaves a truncated config (and the API key) behind.
+    const tmp = configPath() + ".tmp";
+    await writeFile(tmp, JSON.stringify(config, null, 2) + "\n");
+    // The file holds a secret — keep it owner-only. Best-effort on Windows.
+    try {
+        await chmod(tmp, 0o600);
+    }
+    catch {
+        /* chmod is a no-op / unsupported on some platforms */
+    }
+    await rename(tmp, configPath());
+}
+/**
+ * Resolve effective credentials from file config, environment, and flags.
+ * Later sources win. Returns the merged config plus whether it's usable.
+ */
+export function resolveConfig(stored, flags) {
+    const env = {};
+    if (process.env.MYAGENT_BASE_URL)
+        applyBaseUrl(env, process.env.MYAGENT_BASE_URL);
+    if (process.env.MYAGENT_INTEGRATION_ID)
+        env.integrationId = process.env.MYAGENT_INTEGRATION_ID;
+    if (process.env.MYAGENT_API_KEY)
+        env.apiKey = process.env.MYAGENT_API_KEY;
+    if (process.env.MYAGENT_APPROVAL === "ask")
+        env.approvalDefault = "ask";
+    const merged = { ...stored, ...env };
+    // Only override with flags that were actually provided (non-empty).
+    if (flags.baseUrl)
+        applyBaseUrl(merged, flags.baseUrl);
+    if (flags.integrationId)
+        merged.integrationId = flags.integrationId;
+    if (flags.apiKey)
+        merged.apiKey = flags.apiKey;
+    if (flags.approvalDefault)
+        merged.approvalDefault = flags.approvalDefault;
+    return merged;
+}
+/**
+ * Set a base URL on a config patch, deriving the integration id when the URL
+ * is the combined form (`<host>/integrations/<id>`) — a combined URL is
+ * self-contained, so its id is authoritative for that source.
+ */
+function applyBaseUrl(target, baseUrl) {
+    const split = splitIntegrationUrl(baseUrl);
+    target.baseUrl = split.baseUrl;
+    if (split.integrationId)
+        target.integrationId = split.integrationId;
+}
+export function isConfigured(config) {
+    return Boolean(config.baseUrl && config.integrationId && config.apiKey);
+}
+/**
+ * Split a combined API base URL (`<host>/integrations/<id>`) into its parts.
+ * The Integrations page shows this single URL, so pasting it anywhere a base
+ * URL is accepted (wizard, --base-url, MYAGENT_BASE_URL, config file) must
+ * work. A trailing path is tolerated (old clipboards carry full endpoint URLs
+ * like `.../integrations/<id>/v1/chat/completions` — same rule as the
+ * extension's parseEndpointUrl); a URL without `/integrations/<id>` is
+ * returned unchanged.
+ */
+export function splitIntegrationUrl(url) {
+    const trimmed = url.trim();
+    const match = /^(.*?)\/integrations\/([^/]+)(?:\/.*)?$/.exec(trimmed);
+    if (!match)
+        return { baseUrl: trimmed };
+    return { baseUrl: match[1], integrationId: match[2] };
+}
+/** The combined API base URL shown in the UI, for display/copy. */
+export function combinedIntegrationUrl(config) {
+    if (!config.baseUrl || !config.integrationId)
+        return config.baseUrl || "";
+    return `${config.baseUrl.replace(/\/+$/, "")}/integrations/${config.integrationId}`;
+}

package/dist/git/status.d.ts

@@ -0,0 +1,89 @@
+export interface GitFileChange {
+    path: string;
+    /** Porcelain status code (M, A, D, R, ??, …). */
+    status: string;
+    insertions: number;
+    deletions: number;
+}
+export interface GitStatus {
+    isRepo: boolean;
+    branch: string | null;
+    files: GitFileChange[];
+    totalInsertions: number;
+    totalDeletions: number;
+}
+export declare const EMPTY_GIT_STATUS: GitStatus;
+/**
+ * Strip terminal-control sequences from a git-derived string (file paths,
+ * branch names). A malicious repository can carry filenames embedding ANSI/OSC
+ * escape sequences; rendering those raw would inject cursor moves, terminal
+ * title changes, or clipboard writes into the user's terminal. Applied at
+ * the parse boundary so every consumer (sidebar, footer, diff popup) is
+ * covered without each one having to remember.
+ */
+import { sanitizeForTerminal } from "../sanitize.js";
+export { sanitizeForTerminal };
+/**
+ * Parse `git status --porcelain=v1 -z --branch` output. The -z form is
+ * NUL-separated and never quotes paths, so filenames with spaces, quotes,
+ * tabs, or non-ASCII bytes arrive verbatim — no unquoting step to get wrong.
+ * Renames are `XY PATH\0ORIG_PATH\0` (PATH is already the destination).
+ */
+export declare function parsePorcelain(output: string): {
+    branch: string | null;
+    files: Array<{
+        path: string;
+        status: string;
+    }>;
+};
+/**
+ * Parse `git diff --numstat -z` output into a path → line-count map.
+ *
+ * The -z form never quotes or abbreviates: a regular record is
+ * `ins\tdel\tpath\0`; a rename is `ins\tdel\t\0ORIG\0DEST\0` (the stats field
+ * ends at the tab, then the two paths follow as their own NUL fields, orig
+ * first). Keying on DEST matches porcelain -z's destination path, so the
+ * panel's +/- counts line up with the file list for every filename — CJK,
+ * spaces, quotes — instead of silently zeroing on a quoted/abbreviated key.
+ */
+export declare function parseNumstat(output: string): Map<string, {
+    insertions: number;
+    deletions: number;
+}>;
+/** Combine porcelain + staged/unstaged numstat into the panel model. */
+export declare function mergeGitStatus(porcelain: {
+    branch: string | null;
+    files: Array<{
+        path: string;
+        status: string;
+    }>;
+}, unstaged: Map<string, {
+    insertions: number;
+    deletions: number;
+}>, staged: Map<string, {
+    insertions: number;
+    deletions: number;
+}>): GitStatus;
+/** Collect the current git status; never throws. */
+export declare function collectGitStatus(workspace: string, signal?: AbortSignal): Promise<GitStatus>;
+export interface FileDiff {
+    /** Unified diff text (possibly truncated). */
+    text: string;
+    truncated: boolean;
+}
+export declare const MAX_DIFF_LINES = 5000;
+export declare const MAX_DIFF_CHARS: number;
+/** Cut the diff to the char/line budget, reporting whether anything was lost. */
+export declare function truncateDiff(text: string): FileDiff;
+/**
+ * Unified diff for one working-tree file. Tracked files diff against HEAD
+ * (staged + unstaged); when there is no HEAD yet (fresh `git init`) the
+ * index/worktree pair is diffed instead, so staged edits still show.
+ * Untracked files diff against /dev/null, where git exits 1 even on success.
+ *
+ * Porcelain paths are relative to the repository root, so the diff runs from
+ * the root too — otherwise a workspace that is a subdirectory of the repo
+ * resolves the pathspec against the wrong prefix and produces nothing.
+ * Returns an empty text when git cannot produce a diff.
+ */
+export declare function collectFileDiff(workspace: string, file: GitFileChange, signal?: AbortSignal): Promise<FileDiff>;