@getpaseo/cli 0.1.107 → 0.1.108

package/dist/cli.js

@@ -25,6 +25,7 @@ import { addArchiveOptions, runArchiveCommand } from "./commands/agent/archive.j
 import { addAttachOptions, runAttachCommand } from "./commands/agent/attach.js";
 import { addImportOptions, runImportCommand } from "./commands/agent/import.js";
 import { withOutput } from "./output/index.js";
+import { runCloneCommand } from "./commands/clone.js";
 import { onboardCommand } from "./commands/onboard.js";
 import { addDaemonHostOption, addJsonAndDaemonHostOptions, addJsonOption, } from "./utils/command-options.js";
 import { resolveCliVersion } from "./version.js";
@@ -52,6 +53,13 @@ export function createCli() {
     addJsonAndDaemonHostOptions(addLsOptions(program.command("ls"))).action(withOutput(runLsCommand));
     addJsonAndDaemonHostOptions(addRunOptions(program.command("run"))).action(withOutput(runRunCommand));
     addJsonAndDaemonHostOptions(addImportOptions(program.command("import"))).action(withOutput(runImportCommand));
+    addJsonAndDaemonHostOptions(program
+        .command("clone")
+        .description("Clone a GitHub repo and register it as a Paseo workspace")
+        .argument("<repo>", "GitHub repo in owner/repo format or a full git remote URL")
+        .requiredOption("--dir <path>", "Parent directory to clone into (for example: ~/workspace)"))
+        .addOption(new Option("--protocol <protocol>", "Protocol for owner/repo shorthand repositories").choices(["https", "ssh"]))
+        .action(withOutput(runCloneCommand));
     addDaemonHostOption(addAttachOptions(program.command("attach"))).action(runAttachCommand);
     addDaemonHostOption(addLogsOptions(program.command("logs"))).action(runLogsCommand);
     addJsonAndDaemonHostOptions(addStopOptions(program.command("stop"))).action(withOutput(runStopCommand));

package/dist/commands/agent/delete.js

@@ -63,7 +63,7 @@ export async function runDeleteCommand(id, options, _command) {
         const deleteResults = await Promise.all(agents.map(async (agent) => {
             try {
                 if (agent.status === "running") {
-                    await client.cancelAgent(agent.id);
+                    await client.cancelAgent(agent.id).catch(() => { });
                 }
                 await client.deleteAgent(agent.id);
                 return { ok: true, id: agent.id };

package/dist/commands/clone.d.ts

@@ -0,0 +1,17 @@
+import type { Command } from "commander";
+import type { OutputSchema, SingleResult } from "../output/index.js";
+import type { CommandOptions } from "../output/with-output.js";
+type CloneProtocol = "https" | "ssh";
+interface CloneCommandOptions extends CommandOptions {
+    protocol?: CloneProtocol;
+}
+export interface CloneResult {
+    repo: string;
+    checkoutPath: string;
+    projectId: string;
+    projectName: string;
+}
+export declare const cloneSchema: OutputSchema<CloneResult>;
+export declare function runCloneCommand(repo: string, options: CloneCommandOptions, _command: Command): Promise<SingleResult<CloneResult>>;
+export {};
+//# sourceMappingURL=clone.d.ts.map

package/dist/commands/clone.js

@@ -0,0 +1,65 @@
+import { isCompleteGitRemote } from "@getpaseo/protocol/git-remote";
+import { buildDaemonConnectionCommandError, connectToDaemon } from "../utils/client.js";
+export const cloneSchema = {
+    idField: "projectId",
+    columns: [
+        { header: "REPO", field: "repo", width: 28 },
+        { header: "PROJECT", field: "projectName", width: 28 },
+        { header: "PATH", field: "checkoutPath", width: 56 },
+    ],
+};
+function cmdError(code, message, details) {
+    return details ? { code, message, details } : { code, message };
+}
+export async function runCloneCommand(repo, options, _command) {
+    const targetDirectory = typeof options.dir === "string" ? options.dir.trim() : "";
+    if (!targetDirectory) {
+        throw cmdError("INVALID_ARGUMENT", "--dir is required");
+    }
+    const repoIsCompleteRemote = isCompleteGitRemote(repo);
+    if (!repoIsCompleteRemote && !options.protocol) {
+        throw cmdError("INVALID_ARGUMENT", "--protocol is required for owner/repo repository names");
+    }
+    let client;
+    try {
+        client = await connectToDaemon({ host: options.host });
+    }
+    catch (err) {
+        throw buildDaemonConnectionCommandError({ host: options.host, error: err });
+    }
+    if (client.getLastServerInfoMessage()?.features?.projectGithubClone !== true) {
+        await client.close().catch(() => { });
+        throw cmdError("UNSUPPORTED_BY_HOST", "This daemon does not support cloning GitHub repos.", "Update the host to a newer Paseo version.");
+    }
+    try {
+        const response = await client.cloneGithubProject({
+            repo,
+            targetDirectory,
+            ...(repoIsCompleteRemote ? {} : { cloneProtocol: options.protocol }),
+        });
+        if (response.error || !response.project || !response.checkoutPath) {
+            throw cmdError("CLONE_FAILED", `Failed to clone GitHub repo: ${response.error ?? "no project returned"}`);
+        }
+        return {
+            type: "single",
+            data: {
+                repo: response.repo,
+                checkoutPath: response.checkoutPath,
+                projectId: response.project.projectId,
+                projectName: response.project.projectDisplayName,
+            },
+            schema: cloneSchema,
+        };
+    }
+    catch (err) {
+        if (err && typeof err === "object" && "code" in err) {
+            throw err;
+        }
+        const message = err instanceof Error ? err.message : String(err);
+        throw cmdError("CLONE_FAILED", `Failed to clone GitHub repo: ${message}`);
+    }
+    finally {
+        await client.close().catch(() => { });
+    }
+}
+//# sourceMappingURL=clone.js.map

package/dist/utils/client.d.ts

@@ -3,6 +3,11 @@ export interface ConnectOptions {
     host?: string;
     timeout?: number;
 }
+export interface DaemonConnectionCommandError {
+    code: "DAEMON_NOT_RUNNING";
+    message: string;
+    details: string;
+}
 type DaemonTarget = {
     type: "tcp";
     url: string;
@@ -15,6 +20,10 @@ type DaemonTarget = {
  * Get the daemon host from environment or options
  */
 export declare function getDaemonHost(options?: ConnectOptions): string;
+export declare function buildDaemonConnectionCommandError(options: {
+    host?: string;
+    error: unknown;
+}): DaemonConnectionCommandError;
 export declare function normalizeDaemonHost(raw: string): string | null;
 export declare function resolveDefaultDaemonHost(env?: NodeJS.ProcessEnv): string;
 export declare function resolveDefaultDaemonHosts(env?: NodeJS.ProcessEnv): string[];

package/dist/utils/client.js

@@ -16,6 +16,15 @@ const PID_FILENAME = "paseo.pid";
 export function getDaemonHost(options) {
     return resolveDaemonHostCandidates(options)[0] ?? DEFAULT_HOST;
 }
+export function buildDaemonConnectionCommandError(options) {
+    const host = getDaemonHost({ host: options.host });
+    const message = options.error instanceof Error ? options.error.message : String(options.error);
+    return {
+        code: "DAEMON_NOT_RUNNING",
+        message: `Cannot connect to daemon at ${host}: ${message}`,
+        details: "Start the daemon with: paseo daemon start",
+    };
+}
 export function normalizeDaemonHost(raw) {
     const trimmed = raw.trim();
     if (!trimmed) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getpaseo/cli",
-  "version": "0.1.107",
+  "version": "0.1.108",
   "description": "Paseo CLI - control your AI coding agents from the command line",
   "bin": {
     "paseo": "bin/paseo"
@@ -27,9 +27,9 @@
   },
   "dependencies": {
     "@clack/prompts": "^1.0.0",
-    "@getpaseo/client": "0.1.107",
-    "@getpaseo/protocol": "0.1.107",
-    "@getpaseo/server": "0.1.107",
+    "@getpaseo/client": "0.1.108",
+    "@getpaseo/protocol": "0.1.108",
+    "@getpaseo/server": "0.1.108",
     "chalk": "^5.3.0",
     "commander": "^12.0.0",
     "mime-types": "^2.1.35",