@camerontaylor/paseo-cli 0.8.0-fork.1

package/dist/commands/permit/deny.js

@@ -0,0 +1,105 @@
+import { connectToDaemon, getDaemonHost } from "../../utils/client.js";
+import { permitResponseSchema } from "./allow.js";
+export async function runDenyCommand(agentIdOrPrefix, reqId, options, _command) {
+    const host = getDaemonHost({ host: options.host });
+    // Validate arguments
+    if (!options.all && !reqId) {
+        const error = {
+            code: "MISSING_ARGUMENT",
+            message: "Request ID is required unless --all is specified",
+            details: "Usage: paseo permit deny <agent> <req_id> or paseo permit deny <agent> --all",
+        };
+        throw error;
+    }
+    let client;
+    try {
+        client = await connectToDaemon({ host: options.host });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        const error = {
+            code: "DAEMON_NOT_RUNNING",
+            message: `Cannot connect to daemon at ${host}: ${message}`,
+            details: "Start the daemon with: paseo daemon start",
+        };
+        throw error;
+    }
+    try {
+        const fetchResult = await client.fetchAgent({ agentId: agentIdOrPrefix });
+        if (!fetchResult) {
+            await client.close();
+            const error = {
+                code: "AGENT_NOT_FOUND",
+                message: `Agent not found: ${agentIdOrPrefix}`,
+                details: 'Use "paseo ls" to list available agents',
+            };
+            throw error;
+        }
+        const agent = fetchResult.agent;
+        const resolvedAgentId = agent.id;
+        // Get pending permissions for this agent
+        const pendingPermissions = agent.pendingPermissions || [];
+        if (pendingPermissions.length === 0) {
+            await client.close();
+            const error = {
+                code: "NO_PENDING_PERMISSIONS",
+                message: `No pending permissions for agent ${agent.id.slice(0, 7)}`,
+            };
+            throw error;
+        }
+        // Determine which permissions to deny
+        let permissionsToDeny;
+        if (options.all) {
+            permissionsToDeny = pendingPermissions;
+        }
+        else {
+            // Find permission by ID prefix
+            const permission = pendingPermissions.find((p) => p.id === reqId || p.id.startsWith(reqId));
+            if (!permission) {
+                await client.close();
+                const error = {
+                    code: "PERMISSION_NOT_FOUND",
+                    message: `Permission request not found: ${reqId}`,
+                    details: `Available requests: ${pendingPermissions.map((p) => p.id.slice(0, 8)).join(", ")}`,
+                };
+                throw error;
+            }
+            permissionsToDeny = [permission];
+        }
+        // Deny permissions
+        const results = await Promise.all(permissionsToDeny.map(async (permission) => {
+            await client.respondToPermission(resolvedAgentId, permission.id, {
+                behavior: "deny",
+                ...(options.message ? { message: options.message } : {}),
+                ...(options.interrupt ? { interrupt: true } : {}),
+            });
+            return {
+                requestId: permission.id.slice(0, 8),
+                agentId: resolvedAgentId,
+                agentShortId: resolvedAgentId.slice(0, 7),
+                name: permission.name,
+                result: "denied",
+            };
+        }));
+        await client.close();
+        return {
+            type: "list",
+            data: results,
+            schema: permitResponseSchema,
+        };
+    }
+    catch (err) {
+        await client.close().catch(() => { });
+        // Re-throw CommandErrors
+        if (err && typeof err === "object" && "code" in err) {
+            throw err;
+        }
+        const message = err instanceof Error ? err.message : String(err);
+        const error = {
+            code: "DENY_PERMISSION_FAILED",
+            message: `Failed to deny permission: ${message}`,
+        };
+        throw error;
+    }
+}
+//# sourceMappingURL=deny.js.map

package/dist/commands/permit/index.d.ts

@@ -0,0 +1,3 @@
+import { Command } from "commander";
+export declare function createPermitCommand(): Command;
+//# sourceMappingURL=index.d.ts.map

package/dist/commands/permit/index.js

@@ -0,0 +1,27 @@
+import { Command } from "commander";
+import { runLsCommand } from "./ls.js";
+import { runAllowCommand } from "./allow.js";
+import { runDenyCommand } from "./deny.js";
+import { withOutput } from "../../output/index.js";
+import { addJsonAndDaemonHostOptions } from "../../utils/command-options.js";
+export function createPermitCommand() {
+    const permit = new Command("permit").description("Manage permission requests");
+    addJsonAndDaemonHostOptions(permit.command("ls").description("List all pending permissions")).action(withOutput(runLsCommand));
+    addJsonAndDaemonHostOptions(permit
+        .command("allow")
+        .description("Allow a permission request")
+        .argument("<agent>", "Agent ID (or prefix)")
+        .argument("[req_id]", "Permission request ID (optional if --all)")
+        .option("--all", "Allow all pending permissions for this agent")
+        .option("--input <json>", "Modified input parameters (JSON)")).action(withOutput(runAllowCommand));
+    addJsonAndDaemonHostOptions(permit
+        .command("deny")
+        .description("Deny a permission request")
+        .argument("<agent>", "Agent ID (or prefix)")
+        .argument("[req_id]", "Permission request ID (optional if --all)")
+        .option("--all", "Deny all pending permissions for this agent")
+        .option("--message <msg>", "Denial reason message")
+        .option("--interrupt", "Stop agent after denial")).action(withOutput(runDenyCommand));
+    return permit;
+}
+//# sourceMappingURL=index.js.map

package/dist/commands/permit/ls.d.ts

@@ -0,0 +1,18 @@
+import type { Command } from "commander";
+import type { CommandOptions, ListResult, OutputSchema } from "../../output/index.js";
+/** Permission list item for display */
+export interface PermissionListItem {
+    id: string;
+    agentId: string;
+    agentShortId: string;
+    name: string;
+    description: string;
+}
+/** Schema for permit ls output */
+export declare const permitLsSchema: OutputSchema<PermissionListItem>;
+export type PermitLsResult = ListResult<PermissionListItem>;
+export interface PermitLsOptions extends CommandOptions {
+    host?: string;
+}
+export declare function runLsCommand(options: PermitLsOptions, _command: Command): Promise<PermitLsResult>;
+//# sourceMappingURL=ls.d.ts.map

package/dist/commands/permit/ls.js

@@ -0,0 +1,66 @@
+import { connectToDaemon, getDaemonHost } from "../../utils/client.js";
+/** Schema for permit ls output */
+export const permitLsSchema = {
+    idField: "id",
+    columns: [
+        { header: "AGENT", field: "agentShortId", width: 12 },
+        { header: "REQ_ID", field: "id", width: 12 },
+        { header: "TOOL", field: "name", width: 20 },
+        { header: "DESCRIPTION", field: "description", width: 50 },
+    ],
+};
+/** Transform agent snapshot + permission to list item */
+function toListItem(agent, permission) {
+    return {
+        id: permission.id.slice(0, 8),
+        agentId: agent.id,
+        agentShortId: agent.id.slice(0, 7),
+        name: permission.name,
+        description: permission.description ?? "-",
+    };
+}
+export async function runLsCommand(options, _command) {
+    const host = getDaemonHost({ host: options.host });
+    let client;
+    try {
+        client = await connectToDaemon({ host: options.host });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        const error = {
+            code: "DAEMON_NOT_RUNNING",
+            message: `Cannot connect to daemon at ${host}: ${message}`,
+            details: "Start the daemon with: paseo daemon start",
+        };
+        throw error;
+    }
+    try {
+        const agentsPayload = await client.fetchAgents({ filter: { includeArchived: true } });
+        const agents = agentsPayload.entries.map((entry) => entry.agent);
+        await client.close();
+        // Collect all pending permissions from all agents
+        const items = [];
+        for (const agent of agents) {
+            if (agent.pendingPermissions && agent.pendingPermissions.length > 0) {
+                for (const permission of agent.pendingPermissions) {
+                    items.push(toListItem(agent, permission));
+                }
+            }
+        }
+        return {
+            type: "list",
+            data: items,
+            schema: permitLsSchema,
+        };
+    }
+    catch (err) {
+        await client.close().catch(() => { });
+        const message = err instanceof Error ? err.message : String(err);
+        const error = {
+            code: "LIST_PERMISSIONS_FAILED",
+            message: `Failed to list permissions: ${message}`,
+        };
+        throw error;
+    }
+}
+//# sourceMappingURL=ls.js.map

package/dist/commands/plugin/index.d.ts

@@ -0,0 +1,17 @@
+import { Command } from "commander";
+import type { PluginListItem, PluginLogEntry } from "@camerontaylor/paseo-protocol/messages";
+import type { CommandOptions, ListResult, SingleResult } from "../../output/index.js";
+import { type PluginScaffold } from "./scaffold.js";
+interface PluginOptions extends CommandOptions {
+    host?: string;
+    id?: string;
+    ref?: string;
+    path?: string;
+    all?: boolean;
+}
+export declare function runPluginInitCommand(directory: string, options: PluginOptions, _command: Command): Promise<SingleResult<PluginScaffold>>;
+export declare function runPluginListCommand(pluginId: string | undefined, options: PluginOptions, _command: Command): Promise<ListResult<PluginListItem>>;
+export declare function runPluginLogsCommand(pluginId: string, options: PluginOptions, _command: Command): Promise<ListResult<PluginLogEntry>>;
+export declare function createPluginCommand(): Command;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/commands/plugin/index.js

@@ -0,0 +1,138 @@
+import { Command } from "commander";
+import path from "node:path";
+import { formatPluginSourceReference, parsePluginSourceReference, } from "@camerontaylor/paseo-protocol/plugin-source-reference";
+import { withOutput } from "../../output/index.js";
+import { addJsonAndDaemonHostOptions, addJsonOption } from "../../utils/command-options.js";
+import { scaffoldPluginDirectory } from "./scaffold.js";
+import { withPluginLogsClient, withPluginManagementClient, withPluginSourceClient, } from "./shared.js";
+const pluginSchema = {
+    idField: "id",
+    columns: [
+        { header: "PLUGIN", field: "id", width: 20 },
+        { header: "STATUS", field: "status", width: 10 },
+        { header: "ENABLED", field: (plugin) => (plugin.enabled ? "yes" : "no"), width: 8 },
+        { header: "SOURCE", field: (plugin) => plugin.source ?? "directory", width: 10 },
+        { header: "COMMIT", field: (plugin) => shortCommit(plugin.commit), width: 14 },
+        { header: "REF", field: (plugin) => plugin.ref ?? "-", width: 24 },
+        { header: "DIRECTORY", field: "path", width: 40 },
+        { header: "ERROR", field: (plugin) => plugin.error ?? "", width: 40 },
+    ],
+};
+const scaffoldSchema = {
+    idField: "id",
+    columns: [
+        { header: "PLUGIN", field: "id", width: 20 },
+        { header: "DIRECTORY", field: "directory", width: 60 },
+    ],
+};
+const pluginLogsSchema = {
+    idField: (entry) => String(entry.sequence),
+    columns: [
+        { header: "TIME", field: "timestamp", width: 24 },
+        { header: "STREAM", field: "stream", width: 8 },
+        { header: "MESSAGE", field: "message", width: 80 },
+    ],
+};
+function shortCommit(commit) {
+    return commit?.slice(0, 12) ?? "-";
+}
+const pluginUpdateSchema = {
+    idField: "id",
+    columns: [
+        { header: "PLUGIN", field: "id", width: 20 },
+        { header: "PREVIOUS", field: (plugin) => shortCommit(plugin.previousCommit), width: 14 },
+        { header: "CURRENT", field: (plugin) => shortCommit(plugin.currentCommit), width: 14 },
+        { header: "COMMITS", field: (plugin) => String(plugin.commits), width: 8 },
+        { header: "UPDATED", field: (plugin) => (plugin.updated ? "yes" : "no"), width: 8 },
+    ],
+};
+export async function runPluginInitCommand(directory, options, _command) {
+    return {
+        type: "single",
+        data: await scaffoldPluginDirectory(directory, options.id),
+        schema: scaffoldSchema,
+    };
+}
+export async function runPluginListCommand(pluginId, options, _command) {
+    const plugins = await withPluginManagementClient(options.host, (client) => client.listPlugins());
+    const data = pluginId ? plugins.filter((plugin) => plugin.id === pluginId) : plugins;
+    if (pluginId && data.length === 0)
+        throw new Error(`Plugin is not configured: ${pluginId}`);
+    return { type: "list", data, schema: pluginSchema };
+}
+export async function runPluginLogsCommand(pluginId, options, _command) {
+    const data = await withPluginLogsClient(options.host, (client) => client.getPluginLogs(pluginId));
+    return { type: "list", data, schema: pluginLogsSchema };
+}
+async function install(source, options, _command) {
+    process.stderr.write("Trusting plugin code: server code and Git build commands run unsandboxed on the daemon host; client code runs inside Paseo. Dependencies and future updates are part of the codebase you trust.\n");
+    const isExplicitPath = path.isAbsolute(source) ||
+        source === "." ||
+        source === ".." ||
+        source.startsWith("./") ||
+        source.startsWith("../") ||
+        source.startsWith(".\\") ||
+        source.startsWith("..\\");
+    const hasPluginPathSuffix = parsePluginSourceReference(source).pluginPath !== undefined;
+    const canUseLegacyDirectoryInstall = isExplicitPath && !hasPluginPathSuffix && !options.ref && !options.path;
+    const sourceReference = formatPluginSourceReference(source, options.path);
+    const data = canUseLegacyDirectoryInstall
+        ? await withPluginManagementClient(options.host, (client) => client.installDirectoryPlugin(source, options.id))
+        : await withPluginSourceClient(options.host, (client) => client.installPluginSource({
+            source: sourceReference,
+            ...(options.id ? { id: options.id } : {}),
+            ...(options.ref ? { ref: options.ref } : {}),
+        }));
+    return { type: "single", data, schema: pluginSchema };
+}
+async function update(pluginId, options, _command) {
+    if ((pluginId === undefined) === (options.all !== true)) {
+        throw new Error("Choose one plugin ID or pass --all");
+    }
+    const data = await withPluginSourceClient(options.host, (client) => client.updatePluginSources(pluginId));
+    return { type: "list", data, schema: pluginUpdateSchema };
+}
+async function act(action, pluginId, options) {
+    const data = await withPluginManagementClient(options.host, (client) => client[`${action}Plugin`](pluginId));
+    return { type: "single", data, schema: pluginSchema };
+}
+async function remove(pluginId, options, _command) {
+    const data = await withPluginManagementClient(options.host, async (client) => {
+        const current = (await client.listPlugins()).find((plugin) => plugin.id === pluginId);
+        if (!current)
+            throw new Error(`Plugin is not configured: ${pluginId}`);
+        await client.removePlugin(pluginId);
+        return { ...current, enabled: false, status: "disabled" };
+    });
+    return { type: "single", data, schema: pluginSchema };
+}
+export function createPluginCommand() {
+    const plugin = new Command("plugin").description("Manage trusted, unsandboxed plugins");
+    addJsonOption(plugin
+        .command("init")
+        .description("Create a typecheckable local plugin")
+        .argument("<directory>")
+        .option("--id <id>", "Manifest plugin ID (defaults to the directory name)")).action(withOutput(runPluginInitCommand));
+    addJsonAndDaemonHostOptions(plugin.command("ls").description("List configured plugins").argument("[id]")).action(withOutput(runPluginListCommand));
+    addJsonAndDaemonHostOptions(plugin.command("status", { hidden: true }).argument("[id]")).action(withOutput(runPluginListCommand));
+    addJsonAndDaemonHostOptions(plugin.command("logs").description("Show recent plugin output").argument("<id>")).action(withOutput(runPluginLogsCommand));
+    addJsonAndDaemonHostOptions(plugin
+        .command("install")
+        .alias("add")
+        .description("Trust and install a plugin from a directory or Git repository")
+        .argument("<source>", "Host directory, Git source, or Git source:plugin/path")
+        .option("--id <id>", "Runtime plugin ID (defaults to paseo-plugin.json id)")
+        .option("--ref <ref>", "Git branch, tag, or commit")
+        .option("--path <path>", "Legacy form of the :plugin/path source suffix")).action(withOutput(install));
+    addJsonAndDaemonHostOptions(plugin
+        .command("update")
+        .description("Fetch and install Git-managed plugin updates")
+        .argument("[id]")
+        .option("--all", "Update every Git-managed plugin")).action(withOutput(update));
+    for (const action of ["reload", "enable", "disable"]) {
+        addJsonAndDaemonHostOptions(plugin.command(action).description(`${action} a plugin`).argument("<id>")).action(withOutput((id, options, _command) => act(action, id, options)));
+    }
+    addJsonAndDaemonHostOptions(plugin.command("remove").description("Remove plugin configuration").argument("<id>")).action(withOutput(remove));
+    return plugin;
+}
+//# sourceMappingURL=index.js.map

package/dist/commands/plugin/scaffold.d.ts

@@ -0,0 +1,6 @@
+export interface PluginScaffold {
+    id: string;
+    directory: string;
+}
+export declare function scaffoldPluginDirectory(targetDirectory: string, requestedId?: string): Promise<PluginScaffold>;
+//# sourceMappingURL=scaffold.d.ts.map

package/dist/commands/plugin/scaffold.js

@@ -0,0 +1,162 @@
+import { mkdir, readdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { PluginIdSchema } from "@camerontaylor/paseo-protocol/messages";
+import { resolveCliVersion } from "../../version.js";
+const TSCONFIG = {
+    compilerOptions: {
+        target: "ES2020",
+        module: "ESNext",
+        moduleResolution: "Bundler",
+        lib: ["ES2023"],
+        types: ["react"],
+        jsx: "react-jsx",
+        strict: true,
+        skipLibCheck: true,
+        noEmit: true,
+        esModuleInterop: true,
+        allowSyntheticDefaultImports: true,
+    },
+    include: ["**/*.ts", "**/*.tsx"],
+};
+const CLIENT_ENTRY = `import type { PluginClientContext } from "@camerontaylor/paseo-plugin/client";
+import { GreetingSurface } from "./client/greeting";
+
+export default function contribute(client: PluginClientContext) {
+  client.addSurface("greeting", GreetingSurface);
+  client.addSidebarItem({
+    id: "greeting",
+    title: "Greeting",
+    icon: "MessageCircle",
+    surface: "greeting",
+  });
+  return () => {};
+}
+`;
+const SERVER_ENTRY = `import type { PluginServerContext } from "@camerontaylor/paseo-plugin/server";
+import { createGreeting } from "./server/greeting";
+import { greetingRpc } from "./shared/greeting";
+
+export default function contribute(server: PluginServerContext) {
+  server.handle(greetingRpc, createGreeting);
+  return () => {};
+}
+`;
+const SHARED_GREETING = `import { defineRpc } from "@camerontaylor/paseo-plugin";
+import { z } from "zod";
+
+export const greetingRpc = defineRpc({
+  name: "greeting.create",
+  input: z.object({ name: z.string() }),
+  output: z.object({ message: z.string() }),
+});
+`;
+const SERVER_GREETING = `import type { RpcInput } from "@camerontaylor/paseo-plugin";
+import { greetingRpc } from "../shared/greeting";
+
+export function createGreeting({ name }: RpcInput<typeof greetingRpc>) {
+  return { message: "Hello, " + name + "!" };
+}
+`;
+const CLIENT_GREETING = `import type { PluginSurfaceProps } from "@camerontaylor/paseo-plugin/client";
+import { useRpc } from "@camerontaylor/paseo-plugin/client";
+import { useMutation } from "@tanstack/react-query";
+import { useMemo } from "react";
+import { Pressable, Text, View } from "react-native";
+import { greetingRpc } from "../shared/greeting";
+import { openExternal } from "./web";
+
+export function GreetingSurface({ theme, layout }: PluginSurfaceProps) {
+  const createGreeting = useRpc(greetingRpc);
+  const greeting = useMutation({ mutationFn: createGreeting });
+  const styles = useMemo(
+    () => ({
+      screen: {
+        flex: 1,
+        padding: layout.compact ? 16 : 24,
+        backgroundColor: theme.colors.surface0,
+      },
+      text: { color: theme.colors.foreground },
+      button: { padding: 12, backgroundColor: theme.colors.accent },
+      buttonText: { color: theme.colors.accentForeground },
+    }),
+    [theme, layout.compact],
+  );
+  return (
+    <View style={styles.screen}>
+      <Text style={styles.text}>{greeting.data?.message ?? "Ask the daemon for a greeting."}</Text>
+      <Pressable
+        accessibilityRole="button"
+        accessibilityLabel="Create greeting"
+        style={styles.button}
+        onPress={() => greeting.mutate({ name: "Paseo" })}
+      >
+        <Text style={styles.buttonText}>Create greeting</Text>
+      </Pressable>
+      <Pressable
+        accessibilityRole="link"
+        accessibilityLabel="Open the Paseo website"
+        style={styles.button}
+        onPress={() => openExternal("https://paseo.sh")}
+      >
+        <Text style={styles.buttonText}>Open paseo.sh</Text>
+      </Pressable>
+    </View>
+  );
+}
+`;
+const CLIENT_WEB = `import { Linking, Platform } from "react-native";
+
+// This plugin typechecks without the DOM library. Declare only what this module uses.
+declare const window: { open(url: string, target: string, features: string): unknown };
+
+export async function openExternal(url: string): Promise<void> {
+  if (Platform.OS === "web") {
+    window.open(url, "_blank", "noopener,noreferrer");
+    return;
+  }
+  await Linking.openURL(url);
+}
+`;
+export async function scaffoldPluginDirectory(targetDirectory, requestedId) {
+    const directory = path.resolve(targetDirectory);
+    const id = PluginIdSchema.parse(requestedId ?? path.basename(directory));
+    await mkdir(directory, { recursive: true });
+    const existing = await readdir(directory);
+    if (existing.length > 0) {
+        throw new Error(`Plugin directory must be empty: ${directory}`);
+    }
+    const version = resolveCliVersion();
+    const packageJson = {
+        name: id,
+        private: true,
+        version: "0.0.0",
+        scripts: { typecheck: "tsc --noEmit" },
+        devDependencies: {
+            "@camerontaylor/paseo-plugin": version,
+            "@tanstack/react-query": "^5.90.11",
+            "@types/react": "~19.2.0",
+            react: "19.1.0",
+            "react-native": "0.81.5",
+            typescript: "^5.9.3",
+            zod: "^4.4.3",
+        },
+    };
+    const files = new Map([
+        [
+            "paseo-plugin.json",
+            `${JSON.stringify({ id, requirements: { paseo: `>=${version}` } }, null, 2)}\n`,
+        ],
+        ["package.json", `${JSON.stringify(packageJson, null, 2)}\n`],
+        ["tsconfig.json", `${JSON.stringify(TSCONFIG, null, 2)}\n`],
+        ["index.client.tsx", CLIENT_ENTRY],
+        ["index.server.ts", SERVER_ENTRY],
+        ["shared/greeting.ts", SHARED_GREETING],
+        ["server/greeting.ts", SERVER_GREETING],
+        ["client/greeting.tsx", CLIENT_GREETING],
+        ["client/web.ts", CLIENT_WEB],
+    ]);
+    await Promise.all(["shared", "server", "client"].map((name) => mkdir(path.join(directory, name))));
+    await Promise.all([...files].map(([filename, contents]) => writeFile(path.join(directory, filename), contents, { flag: "wx" })));
+    return { id, directory };
+}
+//# sourceMappingURL=scaffold.js.map

package/dist/commands/plugin/shared.d.ts

@@ -0,0 +1,5 @@
+import type { DaemonClient } from "@camerontaylor/paseo-client/internal/daemon-client";
+export declare function withPluginManagementClient<T>(host: string | undefined, run: (client: DaemonClient) => Promise<T>): Promise<T>;
+export declare function withPluginLogsClient<T>(host: string | undefined, run: (client: DaemonClient) => Promise<T>): Promise<T>;
+export declare function withPluginSourceClient<T>(host: string | undefined, run: (client: DaemonClient) => Promise<T>): Promise<T>;
+//# sourceMappingURL=shared.d.ts.map

package/dist/commands/plugin/shared.js

@@ -0,0 +1,30 @@
+import { connectToDaemon } from "../../utils/client.js";
+async function withPluginClient(host, feature, updateMessage, run) {
+    const client = await connectToDaemon({ host });
+    if (client.getLastServerInfoMessage()?.features?.[feature] !== true) {
+        await client.close().catch(() => undefined);
+        throw {
+            code: "DAEMON_UPDATE_REQUIRED",
+            message: updateMessage,
+        };
+    }
+    try {
+        return await run(client);
+    }
+    finally {
+        await client.close().catch(() => undefined);
+    }
+}
+export async function withPluginManagementClient(host, run) {
+    // COMPAT(pluginManagement): added in v0.3.1, remove gate after 2027-08-14.
+    return withPluginClient(host, "pluginManagement", "Update the host to use plugin management.", run);
+}
+export async function withPluginLogsClient(host, run) {
+    // COMPAT(pluginLogs): added in v0.4.0, remove gate after 2027-08-16.
+    return withPluginClient(host, "pluginLogs", "Update the host to view plugin logs.", run);
+}
+export async function withPluginSourceClient(host, run) {
+    // COMPAT(pluginGitManagement): added in v0.7.0, remove gate after 2027-08-26.
+    return withPluginClient(host, "pluginGitManagement", "Update the host to install and update Git plugins.", run);
+}
+//# sourceMappingURL=shared.js.map

package/dist/commands/project/create.d.ts

@@ -0,0 +1,10 @@
+import type { Command } from "commander";
+import type { CommandOptions, SingleResult } from "../../output/index.js";
+import { type ProjectRow } from "./shared.js";
+export declare function resolveProjectPath(input: {
+    pathArg?: string;
+    cwd: string;
+    daemonTarget?: string;
+}): string;
+export declare function runCreateCommand(pathArg: string | undefined, options: CommandOptions, _command: Command): Promise<SingleResult<ProjectRow>>;
+//# sourceMappingURL=create.d.ts.map

package/dist/commands/project/create.js

@@ -0,0 +1,41 @@
+import path from "node:path";
+import { buildDaemonConnectionCommandError, connectToDaemon } from "../../utils/client.js";
+import { projectSchema, toProjectRow } from "./shared.js";
+export function resolveProjectPath(input) {
+    if (input.daemonTarget) {
+        if (input.pathArg === undefined) {
+            throw {
+                code: "MISSING_PATH",
+                message: "Project path is required when targeting a daemon explicitly",
+                details: "Usage: paseo project create <path> --host <host>",
+            };
+        }
+        return input.pathArg;
+    }
+    return path.resolve(input.cwd, input.pathArg ?? ".");
+}
+export async function runCreateCommand(pathArg, options, _command) {
+    const projectPath = resolveProjectPath({
+        pathArg,
+        cwd: process.cwd(),
+        daemonTarget: options.host ?? process.env.PASEO_HOST,
+    });
+    const client = await connectToDaemon({ host: options.host }).catch((error) => {
+        throw buildDaemonConnectionCommandError({ host: options.host, error });
+    });
+    try {
+        const payload = await client.addProject(projectPath);
+        if (!payload.project) {
+            throw new Error(payload.error ?? "Project creation failed");
+        }
+        return { type: "single", data: toProjectRow(payload.project), schema: projectSchema };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw { code: "PROJECT_CREATE_FAILED", message };
+    }
+    finally {
+        await client.close().catch(() => undefined);
+    }
+}
+//# sourceMappingURL=create.js.map

package/dist/commands/project/delete.d.ts

@@ -0,0 +1,9 @@
+import type { Command } from "commander";
+import type { CommandOptions, SingleResult } from "../../output/index.js";
+interface ProjectDeleteResult {
+    projectId: string;
+    removedWorkspaceIds: string[];
+}
+export declare function runDeleteCommand(projectId: string, options: CommandOptions, _command: Command): Promise<SingleResult<ProjectDeleteResult>>;
+export {};
+//# sourceMappingURL=delete.d.ts.map