@waishnav/devspace 1.0.3 → 1.0.4

package/dist/local-agent-availability.js

@@ -0,0 +1,119 @@
+import { spawnSync } from "node:child_process";
+import { delimiter, resolve } from "node:path";
+import { removeDevspaceNodeModulesBinFromPath } from "./local-agent-path.js";
+import { LOCAL_AGENT_PROVIDERS, } from "./local-agent-profiles.js";
+export function getLocalAgentProviderAvailabilitySnapshot(env = process.env) {
+    return LOCAL_AGENT_PROVIDERS.map((provider) => checkLocalAgentProviderAvailability(provider, env));
+}
+export function checkLocalAgentProviderAvailability(provider, env = process.env) {
+    switch (provider) {
+        case "codex":
+            return packageAvailability(provider, "@openai/codex-sdk");
+        case "claude":
+            return packageAvailability(provider, "@anthropic-ai/claude-agent-sdk");
+        case "opencode":
+            return packageAvailability(provider, "@opencode-ai/sdk/v2");
+        case "pi":
+            return commandAvailability(provider, env.PI_COMMAND ?? "pi", {
+                env: piAvailabilityEnvironment(env),
+            });
+        case "cursor":
+            return commandAvailability(provider, "cursor-agent");
+        case "copilot":
+            return commandAvailability(provider, "copilot");
+    }
+}
+export function assertLocalAgentProviderAvailable(provider, env = process.env) {
+    const availability = checkLocalAgentProviderAvailability(provider, env);
+    if (availability.available)
+        return;
+    throw new Error(`${provider} provider is not available: ${availability.reason ?? "provider preflight failed"}`);
+}
+export function formatLocalAgentProviderAvailabilitySummary(providers) {
+    const available = providers
+        .filter((provider) => provider.available)
+        .map((provider) => provider.name);
+    const unavailable = providers
+        .filter((provider) => !provider.available)
+        .map((provider) => `${provider.name} (${provider.reason ?? "unavailable"})`);
+    return [
+        available.length > 0 ? `available: ${available.join(", ")}` : undefined,
+        unavailable.length > 0 ? `unavailable: ${unavailable.join(", ")}` : undefined,
+    ].filter(Boolean).join("; ");
+}
+function packageAvailability(provider, packageName) {
+    try {
+        import.meta.resolve(packageName);
+        return { name: provider, available: true };
+    }
+    catch {
+        return {
+            name: provider,
+            available: false,
+            reason: `${packageName} package not found`,
+        };
+    }
+}
+function commandAvailability(provider, command, options = {}) {
+    const executable = resolveCommand(command, options.env);
+    if (!executable) {
+        return {
+            name: provider,
+            available: false,
+            reason: `${command} executable not found`,
+        };
+    }
+    return { name: provider, available: true };
+}
+function resolveCommand(command, env = process.env) {
+    const commandHasPath = command.includes("/") || command.includes("\\");
+    if (commandHasPath)
+        return executableExists(command, env) ? command : undefined;
+    for (const candidate of candidateCommandPaths(command, env)) {
+        if (executableExists(candidate, env))
+            return candidate;
+    }
+    return undefined;
+}
+function candidateCommandPaths(command, env) {
+    const path = env.PATH;
+    if (!path)
+        return [];
+    const extensions = process.platform === "win32"
+        ? (env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD")
+            .split(";")
+            .filter(Boolean)
+        : [""];
+    const candidates = [];
+    for (const directory of path.split(delimiter)) {
+        if (!directory)
+            continue;
+        for (const extension of extensions) {
+            candidates.push(resolve(directory, `${command}${extension}`));
+        }
+    }
+    return candidates;
+}
+function executableExists(command, env) {
+    const result = spawnSync(command, ["--version"], {
+        encoding: "utf8",
+        env,
+        windowsHide: true,
+        timeout: 5_000,
+    });
+    const code = typeof result.error === "object" && result.error && "code" in result.error
+        ? result.error.code
+        : undefined;
+    return code !== "ENOENT";
+}
+function piAvailabilityEnvironment(env) {
+    if (env.PI_COMMAND)
+        return env;
+    const path = env.PATH;
+    if (!path)
+        return env;
+    return {
+        ...env,
+        PATH: removeDevspaceNodeModulesBinFromPath(path),
+    };
+}

package/dist/local-agent-path.js

@@ -0,0 +1,24 @@
+import { existsSync, readFileSync } from "node:fs";
+import { delimiter, resolve, sep } from "node:path";
+export function removeDevspaceNodeModulesBinFromPath(pathValue) {
+    return pathValue
+        .split(delimiter)
+        .filter((entry) => entry && !isDevspaceNodeModulesBin(entry))
+        .join(delimiter);
+}
+function isDevspaceNodeModulesBin(pathEntry) {
+    const resolvedEntry = resolve(pathEntry);
+    if (!resolvedEntry.endsWith(`${sep}node_modules${sep}.bin`)) {
+        return false;
+    }
+    const packageJson = resolve(resolvedEntry, "..", "..", "package.json");
+    if (!existsSync(packageJson))
+        return false;
+    try {
+        const packageInfo = JSON.parse(readFileSync(packageJson, "utf8"));
+        return packageInfo.name === "@waishnav/devspace";
+    }
+    catch {
+        return false;
+    }
+}

package/dist/local-agent-profiles.js

@@ -0,0 +1,135 @@
+import { existsSync } from "node:fs";
+import { readdir, readFile } from "node:fs/promises";
+import { basename, join, resolve } from "node:path";
+import { parse as parseYaml } from "yaml";
+export const LOCAL_AGENT_PROVIDERS = [
+    "codex",
+    "claude",
+    "opencode",
+    "pi",
+    "cursor",
+    "copilot",
+];
+const FRONTMATTER_DELIMITER = "---";
+const PROVIDERS = new Set(LOCAL_AGENT_PROVIDERS);
+export async function loadLocalAgentProfiles(config, workspaceRoot) {
+    if (!config.subagents)
+        return [];
+    const profileDirs = [
+        config.devspaceAgentsDir,
+        join(workspaceRoot, ".devspace", "agents"),
+    ];
+    const profilesByName = new Map();
+    for (const directory of profileDirs) {
+        for (const profile of await loadProfilesFromDirectory(directory)) {
+            profilesByName.set(profile.name, profile);
+        }
+    }
+    return Array.from(profilesByName.values())
+        .filter((profile) => !profile.disabled)
+        .sort((a, b) => a.name.localeCompare(b.name));
+}
+export function summarizeLocalAgentProfile(profile) {
+    return {
+        name: profile.name,
+        description: profile.description,
+        provider: profile.provider,
+        model: profile.model,
+        thinking: profile.thinking,
+    };
+}
+async function loadProfilesFromDirectory(directory) {
+    const resolvedDirectory = resolve(directory);
+    if (!existsSync(resolvedDirectory))
+        return [];
+    const entries = await readdir(resolvedDirectory, { withFileTypes: true });
+    const profiles = [];
+    for (const entry of entries) {
+        if (!entry.isFile())
+            continue;
+        if (!entry.name.endsWith(".md"))
+            continue;
+        const filePath = join(resolvedDirectory, entry.name);
+        try {
+            profiles.push(await loadProfileFile(filePath));
+        }
+        catch (error) {
+            console.warn(`Skipping invalid subagent profile ${filePath}: ${errorMessage(error)}`);
+        }
+    }
+    return profiles;
+}
+async function loadProfileFile(filePath) {
+    const content = await readFile(filePath, "utf8");
+    const parsed = parseFrontmatter(content, filePath);
+    return profileFromFrontmatter(parsed.frontmatter, parsed.body, filePath);
+}
+function parseFrontmatter(content, filePath) {
+    const normalized = content.replace(/^\uFEFF/, "");
+    const lines = normalized.split(/\r?\n/);
+    if (lines[0]?.trim() !== FRONTMATTER_DELIMITER) {
+        throw new Error(`Subagent profile is missing frontmatter: ${filePath}`);
+    }
+    const endIndex = lines.findIndex((line, index) => index > 0 && line.trim() === FRONTMATTER_DELIMITER);
+    if (endIndex === -1) {
+        throw new Error(`Subagent profile frontmatter is not closed: ${filePath}`);
+    }
+    return {
+        frontmatter: parseProfileYaml(lines.slice(1, endIndex).join("\n"), filePath),
+        body: lines.slice(endIndex + 1).join("\n").trim(),
+    };
+}
+function parseProfileYaml(source, filePath) {
+    let parsed;
+    try {
+        parsed = parseYaml(source) ?? {};
+    }
+    catch (error) {
+        throw new Error(`Unable to parse subagent profile frontmatter: ${filePath}: ${errorMessage(error)}`);
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new Error(`Subagent profile frontmatter must be a mapping: ${filePath}`);
+    }
+    return parsed;
+}
+function profileFromFrontmatter(frontmatter, body, filePath) {
+    const name = readString(frontmatter, "name") ?? basename(filePath, ".md");
+    const description = readString(frontmatter, "description");
+    const provider = readProvider(frontmatter, filePath);
+    if (!description) {
+        throw new Error(`Subagent profile is missing description: ${filePath}`);
+    }
+    return {
+        name,
+        description,
+        provider,
+        model: readString(frontmatter, "model"),
+        thinking: readString(frontmatter, "thinking"),
+        filePath,
+        body,
+        disabled: frontmatter.disabled === true,
+    };
+}
+function readProvider(frontmatter, filePath) {
+    const provider = readString(frontmatter, "provider");
+    if (!provider) {
+        throw new Error(`Subagent profile is missing provider: ${filePath}`);
+    }
+    if (!PROVIDERS.has(provider)) {
+        throw new Error(`Subagent profile provider must be codex, claude, opencode, pi, cursor, or copilot: ${filePath}`);
+    }
+    return provider;
+}
+export function isLocalAgentProvider(value) {
+    return PROVIDERS.has(value);
+}
+function readString(frontmatter, key) {
+    const value = frontmatter[key];
+    if (typeof value !== "string")
+        return undefined;
+    const trimmed = value.trim();
+    return trimmed || undefined;
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/local-agent-runtime.js

@@ -0,0 +1,48 @@
+function sandboxModeFor(writeMode) {
+    switch (writeMode) {
+        case "allowed":
+            return "workspace-write";
+        case "full_access":
+            return "danger-full-access";
+        case "read_only":
+        case undefined:
+            return "read-only";
+    }
+}
+function threadOptionsFor(input) {
+    return {
+        workingDirectory: input.workspace,
+        sandboxMode: sandboxModeFor(input.writeMode),
+        approvalPolicy: "never",
+        model: input.model,
+        modelReasoningEffort: input.thinking,
+    };
+}
+export class CodexSdkLocalAgentRuntime {
+    provider = "codex";
+    codex;
+    constructor(codex) {
+        this.codex = codex;
+    }
+    async run(input) {
+        const options = threadOptionsFor(input);
+        const thread = input.providerSessionId
+            ? this.codex.resumeThread(input.providerSessionId, options)
+            : this.codex.startThread(options);
+        const turn = await thread.run(input.prompt);
+        return {
+            provider: this.provider,
+            providerSessionId: thread.id,
+            finalResponse: turn.finalResponse,
+            items: turn.items,
+        };
+    }
+}
+export async function createCodexSdkLocalAgentRuntime(options, codexFactory) {
+    const factory = codexFactory ?? (await defaultCodexFactory());
+    return new CodexSdkLocalAgentRuntime(factory(options));
+}
+async function defaultCodexFactory() {
+    const module = await import("@openai/codex-sdk");
+    return (options) => new module.Codex(options);
+}

package/dist/local-agent-store.js

@@ -0,0 +1,145 @@
+import { randomUUID } from "node:crypto";
+import { resolve } from "node:path";
+import { openDatabase } from "./db/client.js";
+export class LocalAgentStore {
+    database;
+    constructor(stateDir) {
+        this.database = openDatabase(stateDir);
+    }
+    list(scope = {}) {
+        let rows;
+        if (scope.workspaceId) {
+            rows = this.database.sqlite
+                .prepare(`select * from local_agent_sessions
+           where workspace_id = ?
+           order by updated_at desc`)
+                .all(scope.workspaceId);
+        }
+        else if (scope.workspaceRoot) {
+            rows = this.database.sqlite
+                .prepare(`select * from local_agent_sessions
+           where workspace_root = ?
+           order by updated_at desc`)
+                .all(resolve(scope.workspaceRoot));
+        }
+        else {
+            rows = this.database.sqlite
+                .prepare("select * from local_agent_sessions order by updated_at desc")
+                .all();
+        }
+        return rows.map(rowToLocalAgentRecord);
+    }
+    create(input) {
+        const now = new Date().toISOString();
+        const record = {
+            id: `agt_${randomUUID().replaceAll("-", "").slice(0, 8)}`,
+            workspaceId: input.workspaceId,
+            workspaceRoot: resolve(input.workspaceRoot),
+            profileName: input.profileName,
+            provider: input.provider,
+            model: input.model,
+            thinking: input.thinking,
+            status: "starting",
+            createdAt: now,
+            updatedAt: now,
+        };
+        this.database.sqlite
+            .prepare(`insert into local_agent_sessions (
+          id,
+          workspace_id,
+          workspace_root,
+          profile_name,
+          provider,
+          model,
+          thinking,
+          status,
+          created_at,
+          updated_at
+        ) values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+            .run(record.id, record.workspaceId ?? null, record.workspaceRoot, record.profileName, record.provider, record.model ?? null, record.thinking ?? null, record.status, record.createdAt, record.updatedAt);
+        return record;
+    }
+    get(idOrPrefix) {
+        const exact = this.database.sqlite
+            .prepare(`select * from local_agent_sessions
+         where id = ? or provider_session_id = ?
+         limit 1`)
+            .get(idOrPrefix, idOrPrefix);
+        if (exact)
+            return rowToLocalAgentRecord(exact);
+        const matches = this.database.sqlite
+            .prepare(`select * from local_agent_sessions
+         where id like ? escape '\\' or provider_session_id like ? escape '\\'
+         order by updated_at desc`)
+            .all(`${escapeLike(idOrPrefix)}%`, `${escapeLike(idOrPrefix)}%`);
+        return matches.length === 1 ? rowToLocalAgentRecord(matches[0]) : undefined;
+    }
+    update(id, patch) {
+        const current = this.getById(id);
+        if (!current)
+            throw new Error(`Unknown subagent id: ${id}`);
+        const updated = {
+            ...current,
+            ...patch,
+            updatedAt: new Date().toISOString(),
+        };
+        this.database.sqlite
+            .prepare(`update local_agent_sessions set
+          workspace_id = ?,
+          workspace_root = ?,
+          profile_name = ?,
+          provider = ?,
+          model = ?,
+          thinking = ?,
+          provider_session_id = ?,
+          status = ?,
+          latest_response = ?,
+          error = ?,
+          updated_at = ?
+         where id = ?`)
+            .run(updated.workspaceId ?? null, resolve(updated.workspaceRoot), updated.profileName, updated.provider, updated.model ?? null, updated.thinking ?? null, updated.providerSessionId ?? null, updated.status, updated.latestResponse ?? null, updated.error ?? null, updated.updatedAt, updated.id);
+        return updated;
+    }
+    close() {
+        this.database.close();
+    }
+    getById(id) {
+        const row = this.database.sqlite
+            .prepare("select * from local_agent_sessions where id = ?")
+            .get(id);
+        return row ? rowToLocalAgentRecord(row) : undefined;
+    }
+}
+export function createLocalAgentStore(config) {
+    return new LocalAgentStore(config.stateDir);
+}
+function rowToLocalAgentRecord(row) {
+    return {
+        id: row.id,
+        workspaceId: row.workspace_id ?? undefined,
+        workspaceRoot: row.workspace_root,
+        profileName: row.profile_name,
+        provider: row.provider,
+        model: row.model ?? undefined,
+        thinking: row.thinking ?? undefined,
+        providerSessionId: row.provider_session_id ?? undefined,
+        status: readStatus(row.status),
+        latestResponse: row.latest_response ?? undefined,
+        error: row.error ?? undefined,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+    };
+}
+function readStatus(status) {
+    if (status === "starting" ||
+        status === "running" ||
+        status === "idle" ||
+        status === "error" ||
+        status === "stopped") {
+        return status;
+    }
+    return "error";
+}
+function escapeLike(value) {
+    return value.replaceAll("\\", "\\\\").replaceAll("%", "\\%").replaceAll("_", "\\_");
+}

package/dist/local-agent-targets.js

@@ -0,0 +1,80 @@
+import { isLocalAgentProvider, LOCAL_AGENT_PROVIDERS, } from "./local-agent-profiles.js";
+export function parseLocalAgentRunArgs(args) {
+    const [target, ...rest] = args;
+    if (!target) {
+        throw new Error('Usage: devspace agents run <profile-or-provider-or-id> [--model <model>] [--thinking <level>] "<prompt>"');
+    }
+    let model;
+    let thinking;
+    const promptParts = [];
+    for (let index = 0; index < rest.length; index += 1) {
+        const part = rest[index];
+        if (part === "--model") {
+            const value = rest[index + 1]?.trim();
+            if (!value)
+                throw new Error("Missing value for --model.");
+            model = value;
+            index += 1;
+            continue;
+        }
+        if (part?.startsWith("--model=")) {
+            const value = part.slice("--model=".length).trim();
+            if (!value)
+                throw new Error("Missing value for --model.");
+            model = value;
+            continue;
+        }
+        if (part === "--thinking") {
+            const value = rest[index + 1]?.trim();
+            if (!value)
+                throw new Error("Missing value for --thinking.");
+            thinking = value;
+            index += 1;
+            continue;
+        }
+        if (part?.startsWith("--thinking=")) {
+            const value = part.slice("--thinking=".length).trim();
+            if (!value)
+                throw new Error("Missing value for --thinking.");
+            thinking = value;
+            continue;
+        }
+        promptParts.push(part ?? "");
+    }
+    const prompt = promptParts.join(" ").trim();
+    if (!prompt) {
+        throw new Error('Usage: devspace agents run <profile-or-provider-or-id> [--model <model>] [--thinking <level>] "<prompt>"');
+    }
+    return { target, prompt, model, thinking };
+}
+export function resolveLocalAgentTarget(target, profiles, modelOverride, thinkingOverride) {
+    const profile = profiles.find((candidate) => candidate.name === target);
+    if (profile) {
+        return {
+            kind: "profile",
+            name: profile.name,
+            provider: profile.provider,
+            model: modelOverride ?? profile.model,
+            thinking: thinkingOverride ?? profile.thinking,
+            profile,
+        };
+    }
+    if (isLocalAgentProvider(target)) {
+        return {
+            kind: "provider",
+            name: target,
+            provider: target,
+            model: modelOverride,
+            thinking: thinkingOverride,
+        };
+    }
+    return undefined;
+}
+export function formatAvailableLocalAgentTargets(profiles) {
+    const profileNames = profiles.map((profile) => profile.name);
+    const parts = [
+        profileNames.length > 0 ? `profiles: ${profileNames.join(", ")}` : undefined,
+        `providers: ${LOCAL_AGENT_PROVIDERS.join(", ")}`,
+    ].filter(Boolean);
+    return parts.join("; ");
+}

package/dist/process-sessions.js

@@ -26,7 +26,7 @@ function terminalSize(value, fallback) {
     }
     return value;
 }
-function processEnvironment() {
+function processEnvironment(input) {
     return {
         ...Object.fromEntries(Object.entries(process.env).filter((entry) => entry[1] !== undefined)),
         NO_COLOR: "1",
@@ -37,6 +37,8 @@ function processEnvironment() {
         CODEX_CI: "1",
         LANG: process.env.LANG ?? "C.UTF-8",
         LC_ALL: process.env.LC_ALL ?? "C.UTF-8",
+        ...(input?.workspaceId ? { DEVSPACE_WORKSPACE_ID: input.workspaceId } : {}),
+        ...(input?.workspaceRoot ? { DEVSPACE_WORKSPACE_ROOT: input.workspaceRoot } : {}),
     };
 }
 function codePointLength(value) {
@@ -236,7 +238,10 @@ export class ProcessSessionManager {
         const detached = process.platform !== "win32";
         const child = spawn(input.command, {
             cwd: input.cwd,
-            env: processEnvironment(),
+            env: processEnvironment({
+                workspaceId: input.workspaceId,
+                workspaceRoot: input.workspaceRoot,
+            }),
             stdio: "pipe",
             windowsHide: true,
             detached,
@@ -265,7 +270,10 @@ export class ProcessSessionManager {
         try {
             pty = nodePty.spawn(shell.executable, shell.args, {
                 cwd: input.cwd,
-                env: processEnvironment(),
+                env: processEnvironment({
+                    workspaceId: input.workspaceId,
+                    workspaceRoot: input.workspaceRoot,
+                }),
                 name: "xterm-256color",
                 cols: session.columns,
                 rows: session.rows,