@camerontaylor/paseo-plugin 0.11.0-beta.1.fork.1 → 0.11.1-fork.1

package/dist/client/contracts.d.ts

@@ -103,6 +103,11 @@ interface PluginClientContextAliases {
     addSidebarItem(contribution: PluginSidebarContribution): PluginCleanup;
 }
 export interface PluginClientContext extends PluginCommandCapabilities, PluginClientContextAliases {
+    /** Play a base64-encoded audio file on this client; resolves when playback ends. */
+    playAudio(source: {
+        base64: string;
+        mimeType: string;
+    }): Promise<void>;
     addSettingsScreen(contribution: PluginSettingsScreenContribution): PluginCleanup;
     addScreen(contribution: PluginScreenContribution): PluginCleanup;
     addSidebarHeaderItem(contribution: PluginSidebarItemContribution): PluginCleanup;

package/dist/index.d.ts

@@ -1,3 +1,4 @@
+export { PLUGIN_SDK_PACKAGE_NAMES, pluginSdkEntry } from "./sdk-specifiers.js";
 export type { PluginTheme, PluginWorkspaceSnapshot, PluginAgentSnapshot, PluginThemeColors, PluginThemeContribution, PluginAttachmentSourceContribution, PluginTimelineData, PluginTimelineItem, PluginTimelineTransformResult, PluginCleanup, } from "./contracts.js";
 export { defineSettings, settingsRpc, type SettingsDefinition } from "./settings.js";
 export { defineAttachmentSource, PluginAttachmentItemSchema, PluginAttachmentSearchPayloadSchema, type PluginAttachmentItem, type PluginAttachmentSearchPayload, } from "./attachments.js";

package/dist/index.js

@@ -1,3 +1,5 @@
+// Shared SDK entry. Keep runtime-specific imports and re-exports on /client or /server.
+export { PLUGIN_SDK_PACKAGE_NAMES, pluginSdkEntry } from "./sdk-specifiers.js";
 export { defineSettings, settingsRpc } from "./settings.js";
 export { defineAttachmentSource, PluginAttachmentItemSchema, PluginAttachmentSearchPayloadSchema, } from "./attachments.js";
 export { defineRpc } from "./rpc.js";

package/dist/sdk-specifiers.d.ts

@@ -0,0 +1,3 @@
+export declare const PLUGIN_SDK_PACKAGE_NAMES: readonly [string, "@camerontaylor/paseo-plugin", "@camerontaylor/paseo-plugin"];
+export declare function pluginSdkEntry(specifier: string): string | null;
+//# sourceMappingURL=sdk-specifiers.d.ts.map

package/dist/sdk-specifiers.js

@@ -0,0 +1,18 @@
+// Preserve the public import identity through fork packaging, which rewrites
+// quoted @getpaseo/* module paths to the fork scope. Both names use host modules.
+export const PLUGIN_SDK_PACKAGE_NAMES = [
+    ["@getpaseo", "plugin"].join("/"),
+    "@camerontaylor/paseo-plugin",
+    // The release transform rewrites this entry to the installed host SDK name.
+    "@camerontaylor/paseo-plugin",
+];
+export function pluginSdkEntry(specifier) {
+    for (const name of PLUGIN_SDK_PACKAGE_NAMES) {
+        if (specifier === name)
+            return "";
+        if (specifier.startsWith(`${name}/`))
+            return specifier.slice(name.length);
+    }
+    return null;
+}
+//# sourceMappingURL=sdk-specifiers.js.map

package/dist/server/acp-internal/connection.js

@@ -1,4 +1,4 @@
-import { spawn } from "node:child_process";
+import { spawnProcess, terminateProcess } from "../process.js";
 import { Readable, Writable } from "node:stream";
 import { ClientSideConnection, CLIENT_METHODS, PROTOCOL_VERSION, ndJsonStream, } from "@agentclientprotocol/sdk";
 import { z } from "zod";
@@ -269,9 +269,9 @@ class AcpRuntime {
                 args: options.options.command.slice(1),
                 env: process.env,
             };
-            child = spawn(launch.command, launch.args, {
+            child = spawnProcess(launch.command, launch.args, {
                 env: { ...launch.env, ...options.env },
-                stdio: ["pipe", "pipe", "pipe"],
+                stdio: "pipe",
             });
             spawnFailure = new Promise((_resolve, reject) => child.once("error", reject));
             child.stderr.on("data", () => undefined);
@@ -587,10 +587,10 @@ class AcpRuntime {
         if (child.exitCode !== null || child.signalCode !== null)
             return;
         const closed = new Promise((resolve) => child.once("close", () => resolve()));
-        child.kill("SIGTERM");
+        await terminateProcess(child, "SIGTERM");
         if (await settlesWithin(closed, 1000))
             return;
-        child.kill("SIGKILL");
+        await terminateProcess(child);
         if (!(await settlesWithin(closed, 1000))) {
             throw new Error(`ACP provider ${this.options.options.id} did not terminate after SIGKILL`);
         }

package/dist/server/index.d.ts

@@ -1,4 +1,5 @@
 export type { UsageSourceRegistration, UsageReport, UsageWindow, UsageBalance, UsageDetail, } from "./usage.js";
 export type { PluginHandlerContext, PluginServerContext, PluginServerContribution, PluginSettings, PluginSettingsState, } from "./contracts.js";
 export type { PluginHookContext, PluginHookWorkspace, PluginHookAgent, PluginSessionOpenRequest, PluginTurnOutcome, PluginLifecycleEvents, PluginBeforeRequests, PluginLifecycleRegistration, } from "./lifecycle.js";
+export { spawnProcess, execCommand, terminateProcess } from "./process.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/server/index.js

@@ -1,2 +1,2 @@
-export {};
+export { spawnProcess, execCommand, terminateProcess } from "./process.js";
 //# sourceMappingURL=index.js.map

package/dist/server/lifecycle.d.ts

@@ -68,6 +68,9 @@ export interface PluginLifecycleEvents {
     "agent.created": {
         agent: PluginHookAgent;
     };
+    "agent.closed": {
+        agent: PluginHookAgent;
+    };
     "workspace.created": {
         workspace: PluginHookWorkspace;
     };

package/dist/server/process-internal/windows-command.d.ts

@@ -0,0 +1,15 @@
+export declare function isWindowsCommandScript(executablePath: string): boolean;
+/**
+ * When spawning with `shell: true` on Windows, the command is passed to
+ * `cmd.exe /d /s /c "command args"`. The `/s` strips outer quotes, so a
+ * command path with spaces (e.g. `C:\Program Files\...`) is split at the
+ * space. Wrapping it in quotes produces the correct `"C:\Program Files\..." args`.
+ */
+export declare function quoteWindowsCommand(command: string): string;
+/**
+ * `spawn(..., { shell: true })` on Windows also passes argv through `cmd.exe`.
+ * Any argument containing spaces must be quoted or it will be split before the
+ * child process sees it.
+ */
+export declare function quoteWindowsArgument(argument: string): string;
+//# sourceMappingURL=windows-command.d.ts.map

package/dist/server/process-internal/windows-command.js

@@ -0,0 +1,41 @@
+import { extname } from "node:path";
+export function isWindowsCommandScript(executablePath) {
+    const extension = extname(executablePath).toLowerCase();
+    return process.platform === "win32" && (extension === ".cmd" || extension === ".bat");
+}
+function escapeWindowsCmdValue(value) {
+    if (process.platform !== "win32")
+        return value;
+    const isQuoted = value.startsWith('"') && value.endsWith('"');
+    const unquoted = isQuoted ? value.slice(1, -1) : value;
+    // Do NOT double `%` here. cmd.exe only collapses `%%` → `%` inside batch
+    // files; on the command line / `cmd /c "..."` `%%` stays literal, which
+    // breaks args like git's `--format=%(refname)` (git treats `%%` as the
+    // escape for a literal `%`, so the format atoms become literals).
+    const escaped = unquoted.replace(/([&|^<>()!])/g, "^$1");
+    if (isQuoted || /[\s"]/u.test(unquoted)) {
+        const quoted = escaped
+            .replace(/(\\*)"/g, (_match, slashes) => `${slashes}${slashes}\\"`)
+            .replace(/\\+$/u, (slashes) => `${slashes}${slashes}`);
+        return `"${quoted}"`;
+    }
+    return escaped;
+}
+/**
+ * When spawning with `shell: true` on Windows, the command is passed to
+ * `cmd.exe /d /s /c "command args"`. The `/s` strips outer quotes, so a
+ * command path with spaces (e.g. `C:\Program Files\...`) is split at the
+ * space. Wrapping it in quotes produces the correct `"C:\Program Files\..." args`.
+ */
+export function quoteWindowsCommand(command) {
+    return escapeWindowsCmdValue(command);
+}
+/**
+ * `spawn(..., { shell: true })` on Windows also passes argv through `cmd.exe`.
+ * Any argument containing spaces must be quoted or it will be split before the
+ * child process sees it.
+ */
+export function quoteWindowsArgument(argument) {
+    return escapeWindowsCmdValue(argument);
+}
+//# sourceMappingURL=windows-command.js.map

package/dist/server/process.d.ts

@@ -0,0 +1,25 @@
+import { type ChildProcess, type ChildProcessWithoutNullStreams, type SpawnOptions } from "node:child_process";
+export interface ExecCommandOptions {
+    env?: NodeJS.ProcessEnv;
+    cwd?: string;
+    encoding?: BufferEncoding;
+    killSignal?: NodeJS.Signals;
+    timeout?: number;
+    maxBuffer?: number;
+    shell?: boolean | string;
+    signal?: AbortSignal;
+}
+interface ExecCommandResult {
+    stdout: string;
+    stderr: string;
+}
+/** Launch a CLI with Windows command-script handling and argv quoting. The caller owns env. */
+export declare function spawnProcess(command: string, args: string[], options: SpawnOptions & {
+    stdio: "pipe";
+}): ChildProcessWithoutNullStreams;
+export declare function spawnProcess(command: string, args: string[], options?: SpawnOptions): ChildProcess;
+export declare function execCommand(command: string, args: string[], options?: ExecCommandOptions): Promise<ExecCommandResult>;
+/** Force-stop a CLI, including descendants behind Windows command-script launchers. */
+export declare function terminateProcess(child: ChildProcess, signal?: NodeJS.Signals): Promise<void>;
+export {};
+//# sourceMappingURL=process.d.ts.map

package/dist/server/process.js

@@ -0,0 +1,71 @@
+import { execFile, spawn, } from "node:child_process";
+import { extname } from "node:path";
+import { promisify } from "node:util";
+import { isWindowsCommandScript, quoteWindowsArgument, quoteWindowsCommand, } from "./process-internal/windows-command.js";
+const execFileAsync = promisify(execFile);
+function hasPathSeparator(value) {
+    return value.includes("/") || value.includes("\\");
+}
+function shouldUseWindowsShell(command, requestedShell) {
+    if (isWindowsCommandScript(command)) {
+        return true;
+    }
+    if (requestedShell !== undefined) {
+        return requestedShell;
+    }
+    return process.platform === "win32" && !hasPathSeparator(command) && !extname(command);
+}
+export function spawnProcess(command, args, options) {
+    const spawnOptions = options ?? {};
+    const isWindows = process.platform === "win32";
+    const shell = shouldUseWindowsShell(command, spawnOptions.shell);
+    const shouldQuoteForShell = isWindows && shell !== false;
+    const resolvedCommand = shouldQuoteForShell ? quoteWindowsCommand(command) : command;
+    const resolvedArgs = shouldQuoteForShell ? args.map(quoteWindowsArgument) : args;
+    return spawn(resolvedCommand, resolvedArgs, {
+        ...spawnOptions,
+        env: options?.env,
+        shell,
+        signal: options?.signal,
+        windowsHide: true,
+    });
+}
+export async function execCommand(command, args, options) {
+    const isWindows = process.platform === "win32";
+    const shell = shouldUseWindowsShell(command, options?.shell);
+    const shouldQuoteForShell = isWindows && shell !== false;
+    const resolvedCommand = shouldQuoteForShell ? quoteWindowsCommand(command) : command;
+    const resolvedArgs = shouldQuoteForShell ? args.map(quoteWindowsArgument) : args;
+    return execFileAsync(resolvedCommand, resolvedArgs, {
+        cwd: options?.cwd,
+        env: options?.env,
+        encoding: options?.encoding ?? "utf8",
+        signal: options?.signal,
+        killSignal: options?.killSignal,
+        timeout: options?.timeout,
+        maxBuffer: options?.maxBuffer,
+        shell,
+        windowsHide: true,
+    });
+}
+/** Force-stop a CLI, including descendants behind Windows command-script launchers. */
+export async function terminateProcess(child, signal = "SIGKILL") {
+    if (process.platform !== "win32") {
+        child.kill(signal);
+        return;
+    }
+    if (child.pid === undefined)
+        return;
+    try {
+        await execCommand("taskkill.exe", ["/PID", String(child.pid), "/T", "/F"], {
+            shell: false,
+            timeout: 5000,
+        });
+    }
+    catch (error) {
+        // The process can finish between its close check and taskkill.
+        if (!(error instanceof Error && "code" in error && error.code === 128))
+            throw error;
+    }
+}
+//# sourceMappingURL=process.js.map

package/dist/server/provider.d.ts

@@ -4,6 +4,8 @@ export declare const PROVIDER_PROTOCOL_VERSION: 1;
 export declare const PROVIDER_CAPABILITIES: readonly ["prompt.message", "prompt.command", "prompt.image", "prompt.output_schema", "prompt.steer", "session.archive", "session.configure", "session.list", "session.persistence", "session.revert.both", "session.revert.conversation", "session.revert.files", "session.subsession", "session.unarchive", "permission", "permission.tool_policy", "timeline.plugin"];
 export type ProviderCapability = (typeof PROVIDER_CAPABILITIES)[number];
 export interface ProviderRegistration {
+    /** False rejects nonempty system instructions. Omission preserves the existing provider contract. */
+    supportsSystemPrompt?: boolean;
     /** Equal keys share discovery within this provider. Include effective configuration and execution environment. */
     getCatalogCacheKey?(options: ProviderCatalogOptions): Promise<string | undefined>;
     /** Default executable and arguments; the daemon resolves overrides before status/connect. */

package/dist/server/usage.d.ts

@@ -1,4 +1,4 @@
-import type { ZodType } from "zod";
+import { z, type ZodType } from "zod";
 import type { JsonValue } from "@camerontaylor/paseo-protocol/agent-types";
 export interface UsageWindow {
     id: string;
@@ -33,26 +33,58 @@ export interface UsageDetail {
     value: string;
     tone?: UsageWindow["tone"];
 }
-export interface UsageReport {
-    status: "available" | "unavailable" | "error";
+export type UsageProblem = {
+    kind: "expired";
+    expiresAt: string;
+    refreshedBy?: string;
+} | {
+    kind: "rejected";
+    status: number;
+    refreshedBy?: string;
+} | {
+    kind: "no_quota";
+    detail: string;
+};
+export type UsageReport = {
+    status: "available";
     planLabel?: string;
     windows: UsageWindow[];
     balances?: UsageBalance[];
     details?: UsageDetail[];
-    error?: string;
+} | {
+    status: "unavailable";
+    problem: UsageProblem;
+} | {
+    status: "error";
+    error: string;
+};
+export interface UsageAccount {
+    /** Stable across token rotation; [A-Za-z0-9._-]{1,128}. Never a credential or raw email. */
+    key: string;
+    label?: string;
+    /** Harness owning this login, e.g. Codex, OpenCode, Pi or OMP. */
+    harness?: string;
+    /** Store locator, opaque to the daemon. */
+    input: JsonValue;
 }
+export declare const UsageScopeSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"global">;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"session">;
+    provider: z.ZodString;
+    model: z.ZodOptional<z.ZodString>;
+    env: z.ZodRecord<z.ZodString, z.ZodString>;
+}, z.core.$strip>], "kind">;
+export type UsageScope = z.infer<typeof UsageScopeSchema>;
 export interface UsageSourceRegistration {
     id: string;
     label: string;
     icon?: string;
     input: ZodType;
-    /** Stable account identity, resolved without fetching usage. */
-    identify(input: unknown): Promise<{
-        key: string;
-        label?: string;
-    } | null>;
+    /** Accounts for this scope only. The same key in any scope identifies the same account. */
+    discover(scope: UsageScope): Promise<UsageAccount[]>;
+    /** Re-reads the login store; never writes it. */
     fetch(input: unknown): Promise<UsageReport>;
-    discover(): Promise<JsonValue[]>;
 }
 export declare function windowFromUsedPct(input: {
     id: string;
@@ -63,6 +95,29 @@ export declare function windowFromUsedPct(input: {
     resetsAt?: string | null;
     tone?: UsageWindow["tone"];
 }): UsageWindow;
+/**
+ * Numeric provider windows have one identity and vocabulary, independent of response slots.
+ * Pass null when the provider omits the duration; reset countdowns are not window lengths.
+ * Named API fields (weekly, monthly, etc.) use windowFromUsedPct instead.
+ */
+export declare function windowFromReportedDuration(input: {
+    durationSeconds: number | null;
+    /** Stable quota identity and provider name for a model- or feature-scoped limit. */
+    scope?: {
+        id: string;
+        label: string;
+    };
+    /** Neutral identity and names when the provider does not report a positive duration. */
+    unknown: {
+        id: string;
+        label: string;
+        shortLabel: string;
+    };
+    utilizationPct: number | null | undefined;
+    resetsAt?: string | null;
+    summary?: boolean;
+    tone?: UsageWindow["tone"];
+}): UsageWindow;
 /**
  * The tone scale for anything measured against a known limit, windows and balances alike.
  *
@@ -81,5 +136,5 @@ export declare function balanceToneFromRemaining(remaining: number | null | unde
 /** Percentage of a limit consumed, or null when either side is unknown. */
 export declare function usedPctOf(used: number | null | undefined, limit: number | null | undefined): number | null;
 export declare function hashAccountKey(value: string): string;
-export declare function unavailableUsage(): UsageReport;
+export declare function unavailable(problem: UsageProblem): UsageReport;
 //# sourceMappingURL=usage.d.ts.map

package/dist/server/usage.js

@@ -1,4 +1,14 @@
 import { createHash } from "node:crypto";
+import { z } from "zod";
+export const UsageScopeSchema = z.discriminatedUnion("kind", [
+    z.object({ kind: z.literal("global") }),
+    z.object({
+        kind: z.literal("session"),
+        provider: z.string(),
+        model: z.string().optional(),
+        env: z.record(z.string(), z.string()),
+    }),
+]);
 export function windowFromUsedPct(input) {
     const usedPct = typeof input.utilizationPct === "number" ? input.utilizationPct : null;
     const window = {
@@ -16,6 +26,43 @@ export function windowFromUsedPct(input) {
         window.tone = input.tone;
     return window;
 }
+/**
+ * Numeric provider windows have one identity and vocabulary, independent of response slots.
+ * Pass null when the provider omits the duration; reset countdowns are not window lengths.
+ * Named API fields (weekly, monthly, etc.) use windowFromUsedPct instead.
+ */
+export function windowFromReportedDuration(input) {
+    const duration = input.durationSeconds;
+    const name = duration !== null && Number.isFinite(duration) && duration > 0
+        ? durationWindowName(duration)
+        : input.unknown;
+    const scope = input.scope;
+    return windowFromUsedPct({
+        id: scope ? `${scope.id}:${name.id}` : name.id,
+        label: scope ? `${scope.label} · ${name.label}` : name.label,
+        shortLabel: scope
+            ? `${scope.label}${name.shortLabel ? ` ${name.shortLabel}` : ""}`
+            : name.shortLabel,
+        utilizationPct: input.utilizationPct,
+        resetsAt: input.resetsAt,
+        summary: input.summary,
+        tone: input.tone,
+    });
+}
+function durationWindowName(seconds) {
+    if (seconds === 604800)
+        return { id: "weekly", label: "Weekly", shortLabel: "wk" };
+    const id = seconds === 18000 ? "five_hour" : `${seconds}s`;
+    const units = [
+        [86400, "day", "d"],
+        [3600, "hour", "h"],
+        [60, "minute", "m"],
+        [1, "second", "s"],
+    ];
+    const unit = units.find(([size]) => seconds % size === 0) ?? units[units.length - 1];
+    const amount = seconds / unit[0];
+    return { id, label: `${amount}-${unit[1]}`, shortLabel: `${amount}${unit[2]}` };
+}
 /**
  * The tone scale for anything measured against a known limit, windows and balances alike.
  *
@@ -54,12 +101,7 @@ export function usedPctOf(used, limit) {
 export function hashAccountKey(value) {
     return createHash("sha256").update(value).digest("hex");
 }
-export function unavailableUsage() {
-    return {
-        status: "unavailable",
-        windows: [],
-        balances: [],
-        details: [],
-    };
+export function unavailable(problem) {
+    return { status: "unavailable", problem };
 }
 //# sourceMappingURL=usage.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@camerontaylor/paseo-plugin",
-  "version": "0.11.0-beta.1.fork.1",
+  "version": "0.11.1-fork.1",
   "description": "Paseo plugin SDK package",
   "files": [
     "dist",
@@ -70,8 +70,8 @@
     "use-sync-external-store": "^1.6.0"
   },
   "devDependencies": {
-    "@camerontaylor/paseo-client": "0.11.0-beta.1.fork.1",
-    "@camerontaylor/paseo-protocol": "0.11.0-beta.1.fork.1",
+    "@camerontaylor/paseo-client": "0.11.1-fork.1",
+    "@camerontaylor/paseo-protocol": "0.11.1-fork.1",
     "@types/node": "^20.9.0",
     "@types/react": "~19.2.0",
     "react": "19.1.0",
@@ -81,8 +81,8 @@
     "zod": "^4.4.3"
   },
   "peerDependencies": {
-    "@camerontaylor/paseo-client": "0.11.0-beta.1.fork.1",
-    "@camerontaylor/paseo-protocol": "0.11.0-beta.1.fork.1",
+    "@camerontaylor/paseo-client": "0.11.1-fork.1",
+    "@camerontaylor/paseo-protocol": "0.11.1-fork.1",
     "react": "~19.1.0",
     "react-native": ">=0.81.5",
     "zod": "^4.4.3"