@waishnav/devspace 1.0.2 → 1.0.4

package/dist/cli.js

@@ -1,12 +1,22 @@
 #!/usr/bin/env node
 import { createRequire } from "node:module";
 import { stdin as input, stdout as output } from "node:process";
-import { resolve } from "node:path";
+import { spawn } from "node:child_process";
+import { mkdtempSync, writeFileSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
 import * as prompts from "@clack/prompts";
 import { getShellConfig } from "@earendil-works/pi-coding-agent";
 import { satisfies } from "semver";
 import { loadConfig } from "./config.js";
-import { generateOwnerToken, loadDevspaceFiles, writeDevspaceAuth, writeDevspaceConfig, } from "./user-config.js";
+import { runLocalAgentProvider } from "./local-agent-adapters.js";
+import { isLocalAgentProvider, loadLocalAgentProfiles, } from "./local-agent-profiles.js";
+import { assertLocalAgentProviderAvailable, formatLocalAgentProviderAvailabilitySummary, } from "./local-agent-availability.js";
+import { formatAvailableLocalAgentTargets, parseLocalAgentRunArgs, resolveLocalAgentTarget, } from "./local-agent-targets.js";
+import { createLocalAgentStore } from "./local-agent-store.js";
+import { ensureDevspaceDefaultSkills, generateOwnerToken, loadDevspaceFiles, resolveSubagentsFlag, writeDevspaceAuth, writeDevspaceConfig, } from "./user-config.js";
 import { expandHomePath } from "./roots.js";
 const require = createRequire(import.meta.url);
 const SUPPORTED_NODE_RANGE = ">=20.12 <27";
@@ -28,18 +38,26 @@ async function main(argv) {
         case "config":
             runConfigCommand(args);
             return;
+        case "agents":
+            await runAgentsCommand(args);
+            return;
         case "help":
             printHelp();
             return;
+        case "version":
+            printVersion();
+            return;
     }
 }
 function normalizeCommand(command) {
     if (!command || command === "serve" || command === "start")
         return "serve";
-    if (command === "init" || command === "doctor" || command === "config")
+    if (command === "init" || command === "doctor" || command === "config" || command === "agents")
         return command;
     if (command === "help" || command === "--help" || command === "-h")
         return "help";
+    if (command === "version" || command === "--version" || command === "-v")
+        return "version";
     throw new Error(`Unknown command: ${command}`);
 }
 async function ensureConfigured() {
@@ -108,15 +126,18 @@ async function runInit({ force }) {
             port,
             allowedRoots,
             publicBaseUrl,
+            subagents: resolveSubagentsFlag(files.config),
         };
         const auth = {
             ownerToken: files.auth.ownerToken ?? generateOwnerToken(),
         };
         const configPath = writeDevspaceConfig(config);
         const authPath = writeDevspaceAuth(auth);
+        const seededSkillPaths = config.subagents ? ensureDevspaceDefaultSkills() : [];
         const lines = [
             `Config: ${configPath}`,
             `Auth: ${authPath}`,
+            ...seededSkillPaths.map((path) => `Default skill: ${path}`),
             `Local MCP URL: http://${config.host}:${config.port}/mcp`,
             ...(publicBaseUrl ? [`Public MCP URL: ${publicBaseUrl}/mcp`] : []),
         ];
@@ -149,7 +170,7 @@ async function serve() {
     }
     const { createServer } = await import("./server.js");
     const config = loadConfig();
-    const { app, close } = createServer(config);
+    const { app, close, localAgentProviders } = createServer(config);
     const httpServer = app.listen(config.port, config.host, () => {
         console.log(`devspace listening on http://${config.host}:${config.port}/mcp`);
         console.log(`public base url: ${config.publicBaseUrl}`);
@@ -160,6 +181,9 @@ async function serve() {
         }
         console.log("auth: Owner password approval required");
         console.log(`logging: ${config.logging.level} ${config.logging.format}`);
+        if (config.subagents) {
+            console.log(`subagent providers: ${formatLocalAgentProviderAvailabilitySummary(localAgentProviders)}`);
+        }
     });
     const shutdown = () => {
         httpServer.close(() => {
@@ -226,11 +250,239 @@ function printHelp() {
         "  devspace doctor          Show config, runtime, and native dependency status",
         "  devspace config get      Print persisted config",
         "  devspace config set publicBaseUrl <url|null>",
+        "  devspace agents ls       List subagent sessions",
+        "  devspace agents run <profile-or-provider-or-id> [--model <model>] <prompt>",
+        "  devspace agents show <id>",
+        "  devspace -v, --version   Print the installed version",
         "",
         "For temporary tunnels:",
         "  DEVSPACE_PUBLIC_BASE_URL=https://example.trycloudflare.com devspace serve",
     ].join("\n"));
 }
+async function runAgentsCommand(args) {
+    const [subcommand, ...rest] = args;
+    switch (subcommand) {
+        case "ls":
+        case "list":
+            await runAgentsList();
+            return;
+        case "run":
+            await runAgentsRun(rest);
+            return;
+        case "show":
+            await runAgentsShow(rest);
+            return;
+        case "__worker":
+            await runAgentsWorker(rest);
+            return;
+        case undefined:
+        case "help":
+        case "--help":
+        case "-h":
+            printAgentsHelp();
+            return;
+        default:
+            throw new Error(`Unknown agents command: ${subcommand}`);
+    }
+}
+async function runAgentsList() {
+    const config = loadConfig();
+    const store = createLocalAgentStore(config);
+    const agents = store.list(resolveCurrentWorkspaceScope());
+    if (agents.length === 0) {
+        console.log("No subagent sessions found for this workspace.");
+        return;
+    }
+    for (const agent of agents) {
+        console.log(formatAgentLine(agent));
+    }
+}
+async function runAgentsRun(args) {
+    const parsed = parseLocalAgentRunArgs(args);
+    const config = loadConfig();
+    const workspaceRoot = resolveCurrentWorkspaceRoot();
+    const store = createLocalAgentStore(config);
+    const existing = store.get(parsed.target);
+    if (existing) {
+        if (!isLocalAgentProvider(existing.provider)) {
+            throw new Error(`Unknown subagent provider for existing session: ${existing.provider}`);
+        }
+        assertLocalAgentProviderAvailable(existing.provider);
+        const promptFile = writeAgentPromptFile(parsed.prompt);
+        store.update(existing.id, {
+            status: "starting",
+            model: parsed.model ?? existing.model,
+            thinking: parsed.thinking ?? existing.thinking,
+            latestResponse: undefined,
+            error: undefined,
+        });
+        spawnAgentWorker(existing.id, promptFile);
+        console.log(formatAgentLine({
+            ...existing,
+            status: "running",
+            model: parsed.model ?? existing.model,
+            thinking: parsed.thinking ?? existing.thinking,
+        }));
+        return;
+    }
+    const profiles = await loadLocalAgentProfiles(config, workspaceRoot);
+    const target = resolveLocalAgentTarget(parsed.target, profiles, parsed.model, parsed.thinking);
+    if (!target) {
+        throw new Error(`Unknown subagent profile, provider, or id: ${parsed.target}. Available ${formatAvailableLocalAgentTargets(profiles)}`);
+    }
+    assertLocalAgentProviderAvailable(target.provider);
+    const promptFile = writeAgentPromptFile(parsed.prompt);
+    const record = store.create({
+        workspaceId: process.env.DEVSPACE_WORKSPACE_ID,
+        workspaceRoot,
+        profileName: target.name,
+        provider: target.provider,
+        model: target.model,
+        thinking: target.thinking,
+    });
+    spawnAgentWorker(record.id, promptFile);
+    console.log(formatAgentLine({ ...record, status: "running" }));
+}
+async function runAgentsShow(args) {
+    const [id] = args;
+    if (!id)
+        throw new Error("Usage: devspace agents show <id>");
+    const config = loadConfig();
+    const store = createLocalAgentStore(config);
+    let record = store.get(id);
+    if (!record)
+        throw new Error(`Unknown subagent id: ${id}`);
+    const deadline = Date.now() + 15_000;
+    while ((record.status === "starting" || record.status === "running") && Date.now() < deadline) {
+        await sleep(500);
+        record = store.get(id) ?? record;
+    }
+    console.log(formatAgentLine(record));
+    if (record.latestResponse) {
+        console.log(record.latestResponse);
+        return;
+    }
+    if (record.error) {
+        console.log(record.error);
+        return;
+    }
+    if (record.status === "starting" || record.status === "running") {
+        console.log(`No final response yet. Call \`devspace agents show ${record.id}\` again later.`);
+    }
+}
+async function runAgentsWorker(args) {
+    const [id, promptFileFlag, promptFile] = args;
+    if (!id || promptFileFlag !== "--prompt-file" || !promptFile) {
+        throw new Error("Usage: devspace agents __worker <id> --prompt-file <path>");
+    }
+    const config = loadConfig();
+    const store = createLocalAgentStore(config);
+    const record = store.get(id);
+    if (!record)
+        throw new Error(`Unknown subagent id: ${id}`);
+    store.update(record.id, { status: "running", error: undefined });
+    try {
+        const profiles = await loadLocalAgentProfiles(config, record.workspaceRoot);
+        const profile = profiles.find((candidate) => candidate.name === record.profileName);
+        const prompt = await readFile(promptFile, "utf8");
+        const result = profile
+            ? await runLocalAgentProfile(profile, record, prompt)
+            : await runRawLocalAgentProvider(record, prompt);
+        store.update(record.id, {
+            providerSessionId: result.providerSessionId ?? undefined,
+            status: "idle",
+            latestResponse: result.finalResponse,
+            error: undefined,
+        });
+    }
+    catch (error) {
+        store.update(record.id, {
+            status: "error",
+            error: error instanceof Error ? error.message : String(error),
+        });
+    }
+}
+async function runLocalAgentProfile(profile, record, prompt) {
+    const body = profile.body.trim();
+    const fullPrompt = body ? `${body}\n\nTask:\n${prompt}` : prompt;
+    return runLocalAgentProvider(profile.provider, {
+        prompt: fullPrompt,
+        workspace: record.workspaceRoot,
+        providerSessionId: record.providerSessionId,
+        writeMode: "allowed",
+        model: record.model ?? profile.model,
+        thinking: record.thinking ?? profile.thinking,
+    });
+}
+async function runRawLocalAgentProvider(record, prompt) {
+    if (record.profileName !== record.provider || !isLocalAgentProvider(record.provider)) {
+        throw new Error(`Subagent profile not found: ${record.profileName}`);
+    }
+    return runLocalAgentProvider(record.provider, {
+        prompt,
+        workspace: record.workspaceRoot,
+        providerSessionId: record.providerSessionId,
+        writeMode: "allowed",
+        model: record.model,
+        thinking: record.thinking,
+    });
+}
+function spawnAgentWorker(agentId, promptFile) {
+    const child = spawn(process.execPath, [
+        ...process.execArgv,
+        fileURLToPath(import.meta.url),
+        "agents",
+        "__worker",
+        agentId,
+        "--prompt-file",
+        promptFile,
+    ], {
+        detached: true,
+        stdio: "ignore",
+        env: process.env,
+    });
+    child.unref();
+}
+function writeAgentPromptFile(prompt) {
+    const directory = mkdtempSync(join(tmpdir(), "devspace-agent-prompt-"));
+    const filePath = join(directory, "prompt.txt");
+    writeFileSync(filePath, prompt, { mode: 0o600 });
+    return filePath;
+}
+function resolveCurrentWorkspaceRoot() {
+    return resolve(process.env.DEVSPACE_WORKSPACE_ROOT || process.cwd());
+}
+function resolveCurrentWorkspaceScope() {
+    return {
+        workspaceId: process.env.DEVSPACE_WORKSPACE_ID,
+        workspaceRoot: resolveCurrentWorkspaceRoot(),
+    };
+}
+function formatAgentLine(agent) {
+    const model = agent.model ? ` ${agent.model}` : "";
+    const thinking = agent.thinking ? ` thinking=${agent.thinking}` : "";
+    return `${agent.id} ${agent.status} ${agent.profileName} ${agent.provider}${model}${thinking}`;
+}
+function sleep(ms) {
+    return new Promise((resolveSleep) => setTimeout(resolveSleep, ms));
+}
+function printAgentsHelp() {
+    console.log([
+        "DevSpace agents",
+        "",
+        "Usage:",
+        "  devspace agents ls",
+        "  devspace agents run <profile-or-provider-or-id> [--model <model>] [--thinking <level>] <prompt>",
+        "  devspace agents show <id>",
+    ].join("\n"));
+}
+function printVersion() {
+    const packageJson = require("../package.json");
+    if (typeof packageJson.version !== "string") {
+        throw new Error("Unable to read DevSpace package version.");
+    }
+    console.log(packageJson.version);
+}
 function normalizeOptionalPublicBaseUrl(value) {
     const trimmed = value.trim();
     if (!trimmed || trimmed === "null" || trimmed === "none")

package/dist/config.js

@@ -1,7 +1,7 @@
 import { homedir } from "node:os";
 import { join, resolve } from "node:path";
 import { expandHomePath } from "./roots.js";
-import { loadDevspaceFiles } from "./user-config.js";
+import { devspaceAgentsDir, devspaceSkillsDir, loadDevspaceFiles } from "./user-config.js";
 const DEFAULT_OAUTH_ACCESS_TOKEN_TTL_SECONDS = 60 * 60;
 const DEFAULT_OAUTH_REFRESH_TOKEN_TTL_SECONDS = 30 * 24 * 60 * 60;
 function parsePort(value) {
@@ -44,17 +44,16 @@ function normalizeAllowedHosts(rawHosts, derivedHosts) {
 function parseBoolean(value) {
     return ["1", "true", "yes", "on"].includes(value?.toLowerCase() ?? "");
 }
-function parseMinimalTools(env) {
-    if (env.DEVSPACE_TOOL_MODE === "minimal")
-        return true;
-    if (env.DEVSPACE_TOOL_MODE === "full")
-        return false;
-    if (env.DEVSPACE_TOOL_MODE) {
-        throw new Error(`Invalid DEVSPACE_TOOL_MODE: ${env.DEVSPACE_TOOL_MODE}`);
+function parseToolMode(env) {
+    const mode = env.DEVSPACE_TOOL_MODE;
+    if (mode === "minimal" || mode === "full" || mode === "codex")
+        return mode;
+    if (mode)
+        throw new Error(`Invalid DEVSPACE_TOOL_MODE: ${mode}`);
+    if (env.DEVSPACE_MINIMAL_TOOLS !== undefined) {
+        return parseBoolean(env.DEVSPACE_MINIMAL_TOOLS) ? "minimal" : "full";
     }
-    if (env.DEVSPACE_MINIMAL_TOOLS !== undefined)
-        return parseBoolean(env.DEVSPACE_MINIMAL_TOOLS);
-    return true;
+    return "minimal";
 }
 function parseLogLevel(value) {
     if (!value || value === "info")
@@ -74,8 +73,7 @@ function parsePathList(value) {
     return (value
         ?.split(",")
         .map((entry) => entry.trim())
-        .filter(Boolean)
-        .map((entry) => resolve(expandHomePath(entry))) ?? []);
+        .filter(Boolean) ?? []);
 }
 function parseStringList(value, fallback) {
     const entries = value
@@ -93,13 +91,6 @@ function parsePositiveInteger(value, fallback, name) {
     }
     return parsed;
 }
-function parseToolNaming(value) {
-    if (!value || value === "short")
-        return "short";
-    if (value === "legacy")
-        return "legacy";
-    throw new Error(`Invalid DEVSPACE_TOOL_NAMING: ${value}`);
-}
 function parseLoggingConfig(env) {
     return {
         level: parseLogLevel(env.DEVSPACE_LOG_LEVEL),
@@ -170,13 +161,17 @@ export function loadConfig(env = process.env) {
         allowedRoots: parseAllowedRoots(env.DEVSPACE_ALLOWED_ROOTS ?? files.config.allowedRoots),
         allowedHosts: parseAllowedHosts(env.DEVSPACE_ALLOWED_HOSTS, derivedAllowedHosts),
         publicBaseUrl,
-        minimalTools: parseMinimalTools(env),
-        toolNaming: parseToolNaming(env.DEVSPACE_TOOL_NAMING),
+        toolMode: parseToolMode(env),
         widgets: parseWidgetMode(env.DEVSPACE_WIDGETS),
         stateDir: resolve(expandHomePath(env.DEVSPACE_STATE_DIR ?? files.config.stateDir ?? defaultStateDir())),
         worktreeRoot: resolve(expandHomePath(env.DEVSPACE_WORKTREE_ROOT ?? files.config.worktreeRoot ?? defaultWorktreeRoot())),
         skillsEnabled: env.DEVSPACE_SKILLS === undefined ? true : parseBoolean(env.DEVSPACE_SKILLS),
         skillPaths: parsePathList(env.DEVSPACE_SKILL_PATHS),
+        devspaceSkillsDir: devspaceSkillsDir(env),
+        devspaceAgentsDir: devspaceAgentsDir(env),
+        subagents: env.DEVSPACE_SUBAGENTS === undefined
+            ? files.config.subagents === true
+            : parseBoolean(env.DEVSPACE_SUBAGENTS),
         agentDir: resolve(expandHomePath(env.DEVSPACE_AGENT_DIR ?? files.config.agentDir ?? defaultAgentDir())),
         logging: parseLoggingConfig(env),
     };

package/dist/db/migrations.js

@@ -9,6 +9,11 @@ const migrations = [
         name: "oauth-state",
         up: migrateOAuthState,
     },
+    {
+        version: 3,
+        name: "local-agent-sessions",
+        up: migrateLocalAgentSessions,
+    },
 ];
 export function migrateDatabase(sqlite) {
     const migrate = sqlite.transaction(() => {
@@ -115,6 +120,35 @@ function migrateOAuthState(sqlite) {
       on oauth_refresh_tokens(expires_at);
   `);
 }
+function migrateLocalAgentSessions(sqlite) {
+    sqlite.exec(`
+    create table if not exists local_agent_sessions (
+      id text primary key,
+      workspace_id text,
+      workspace_root text not null,
+      profile_name text not null,
+      provider text not null,
+      model text,
+      thinking text,
+      provider_session_id text,
+      status text not null,
+      latest_response text,
+      error text,
+      created_at text not null,
+      updated_at text not null
+    );
+
+    create index if not exists local_agent_sessions_workspace_id_idx
+      on local_agent_sessions(workspace_id, updated_at desc);
+
+    create index if not exists local_agent_sessions_workspace_root_idx
+      on local_agent_sessions(workspace_root, updated_at desc);
+
+    create index if not exists local_agent_sessions_provider_session_id_idx
+      on local_agent_sessions(provider_session_id);
+  `);
+    addColumnIfMissing(sqlite, "local_agent_sessions", "thinking", "text");
+}
 function addColumnIfMissing(sqlite, table, column, definition) {
     const columns = sqlite.prepare(`pragma table_info(${table})`).all();
     if (columns.some((existingColumn) => existingColumn.name === column))

package/dist/db/schema.js

@@ -50,3 +50,22 @@ export const oauthRefreshTokens = sqliteTable("oauth_refresh_tokens", {
     expiresAt: integer("expires_at").notNull(),
     resource: text("resource"),
 });
+export const localAgentSessions = sqliteTable("local_agent_sessions", {
+    id: text("id").primaryKey(),
+    workspaceId: text("workspace_id"),
+    workspaceRoot: text("workspace_root").notNull(),
+    profileName: text("profile_name").notNull(),
+    provider: text("provider").notNull(),
+    model: text("model"),
+    thinking: text("thinking"),
+    providerSessionId: text("provider_session_id"),
+    status: text("status").notNull(),
+    latestResponse: text("latest_response"),
+    error: text("error"),
+    createdAt: text("created_at").notNull(),
+    updatedAt: text("updated_at").notNull(),
+}, (table) => [
+    index("local_agent_sessions_workspace_id_idx").on(table.workspaceId, table.updatedAt),
+    index("local_agent_sessions_workspace_root_idx").on(table.workspaceRoot, table.updatedAt),
+    index("local_agent_sessions_provider_session_id_idx").on(table.providerSessionId),
+]);