@orchagent/cli 0.3.90 → 0.3.92

package/dist/commands/workspace.js

@@ -16,15 +16,24 @@ function deriveSlug(name) {
 async function resolveWorkspaceId(config, slug) {
     const configFile = await (0, config_1.loadConfig)();
     const targetSlug = slug ?? configFile.workspace;
-    if (!targetSlug) {
-        throw new errors_1.CliError('No workspace specified. Use --workspace <slug> or run `orchagent workspace use <slug>` first.');
-    }
     const response = await (0, api_1.request)(config, 'GET', '/workspaces');
-    const workspace = response.workspaces.find((w) => w.slug === targetSlug);
-    if (!workspace) {
-        throw new errors_1.CliError(`Workspace '${targetSlug}' not found.`);
+    if (targetSlug) {
+        const workspace = response.workspaces.find((w) => w.slug === targetSlug);
+        if (!workspace) {
+            throw new errors_1.CliError(`Workspace '${targetSlug}' not found.`);
+        }
+        return workspace.id;
+    }
+    // No workspace specified — auto-select if user has exactly one
+    if (response.workspaces.length === 0) {
+        throw new errors_1.CliError('No workspaces found. Create one with `orch workspace create <name>`.');
+    }
+    if (response.workspaces.length === 1) {
+        return response.workspaces[0].id;
     }
-    return workspace.id;
+    const slugs = response.workspaces.map((w) => w.slug).join(', ');
+    throw new errors_1.CliError(`Multiple workspaces available: ${slugs}\n` +
+        'Specify one with --workspace <slug> or run `orch workspace use <slug>`.');
 }
 async function listWorkspaces(config, options) {
     const response = await (0, api_1.request)(config, 'GET', '/workspaces');

package/dist/lib/agent-ref.js

@@ -6,8 +6,11 @@ function parseAgentRef(value, defaultVersion = 'latest') {
     const [ref, versionPart] = value.split('@');
     const version = versionPart?.trim() || defaultVersion;
     const segments = ref.split('/');
+    if (segments.length === 1) {
+        return { org: undefined, agent: segments[0], version };
+    }
     if (segments.length === 2) {
         return { org: segments[0], agent: segments[1], version };
     }
-    throw new errors_1.CliError('Invalid agent reference. Use org/agent[@version] format');
+    throw new errors_1.CliError('Invalid agent reference. Use agent or org/agent[@version] format');
 }

package/dist/lib/browser-auth.js

@@ -59,6 +59,7 @@ async function waitForCallback(port, timeoutMs) {
         let server = null;
         const cleanup = () => {
             if (server) {
+                server.closeAllConnections();
                 server.close();
                 server = null;
             }

package/dist/lib/scaffold-orchestration.js

@@ -0,0 +1,237 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dependencyRef = dependencyRef;
+exports.validateScaffoldAgentName = validateScaffoldAgentName;
+exports.dedupeOrchestrationDependencies = dedupeOrchestrationDependencies;
+exports.buildOrchestrationCustomTools = buildOrchestrationCustomTools;
+exports.buildOrchestrationManifest = buildOrchestrationManifest;
+exports.buildOrchestrationPrompt = buildOrchestrationPrompt;
+exports.buildOrchestrationSchema = buildOrchestrationSchema;
+const BUILTIN_TOOL_NAMES = new Set([
+    'bash',
+    'read_file',
+    'write_file',
+    'list_files',
+    'submit_result',
+]);
+const DEFAULT_MAX_TURNS = 25;
+const DEFAULT_TIMEOUT_MS = 180000;
+const DEFAULT_PER_CALL_DOWNSTREAM_CAP = 50;
+function dependencyId(dep) {
+    return `${dep.org}/${dep.name}`;
+}
+function dependencyRef(dep) {
+    return `${dependencyId(dep)}@${dep.version}`;
+}
+function sanitizeToolToken(value) {
+    const token = value
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '_')
+        .replace(/^_+|_+$/g, '');
+    return token || 'dependency';
+}
+function defaultToolInputSchema() {
+    return {
+        type: 'object',
+        description: 'JSON payload forwarded to the dependency agent',
+        additionalProperties: true,
+    };
+}
+function normalizeToolInputSchema(inputSchema) {
+    if (!inputSchema || typeof inputSchema !== 'object' || Array.isArray(inputSchema)) {
+        return defaultToolInputSchema();
+    }
+    return inputSchema;
+}
+function summarizeDependencyDescription(dep) {
+    const prefix = `Call ${dependencyRef(dep)}`;
+    const raw = dep.description?.trim();
+    if (!raw)
+        return prefix;
+    const compact = raw.replace(/\s+/g, ' ');
+    if (compact.length <= 140)
+        return `${prefix}: ${compact}`;
+    return `${prefix}: ${compact.slice(0, 137)}...`;
+}
+function nextUniqueToolName(dep, usedNames) {
+    const candidates = [
+        `call_${sanitizeToolToken(dep.name)}`,
+        `call_${sanitizeToolToken(dep.org)}_${sanitizeToolToken(dep.name)}`,
+    ];
+    for (const candidate of candidates) {
+        if (!usedNames.has(candidate) && !BUILTIN_TOOL_NAMES.has(candidate)) {
+            usedNames.add(candidate);
+            return candidate;
+        }
+    }
+    let suffix = 2;
+    const stablePrefix = `call_${sanitizeToolToken(dep.org)}_${sanitizeToolToken(dep.name)}`;
+    while (true) {
+        const candidate = `${stablePrefix}_${suffix}`;
+        if (!usedNames.has(candidate) && !BUILTIN_TOOL_NAMES.has(candidate)) {
+            usedNames.add(candidate);
+            return candidate;
+        }
+        suffix += 1;
+    }
+}
+function defaultMaxHops(depCount) {
+    return Math.max(2, Math.min(8, depCount + 1));
+}
+function validateScaffoldAgentName(name) {
+    const errors = [];
+    const trimmed = name.trim();
+    const nameRegex = /^[a-z0-9][a-z0-9-]*[a-z0-9]$/;
+    if (trimmed.length < 2 || trimmed.length > 50) {
+        errors.push('Agent name must be 2-50 characters');
+    }
+    if (trimmed !== trimmed.toLowerCase()) {
+        errors.push('Agent name must be lowercase');
+    }
+    if (trimmed.length > 1 && !nameRegex.test(trimmed)) {
+        errors.push('Agent name must contain only lowercase letters, numbers, and hyphens, and must start/end with a letter or number');
+    }
+    if (trimmed.includes('--')) {
+        errors.push('Agent name must not contain consecutive hyphens');
+    }
+    return errors;
+}
+function dedupeOrchestrationDependencies(dependencies) {
+    const deduped = [];
+    const duplicates = [];
+    const byId = new Map();
+    const versionsById = new Map();
+    for (const dep of dependencies) {
+        const id = dependencyId(dep);
+        const existing = byId.get(id);
+        if (!existing) {
+            byId.set(id, dep);
+            deduped.push(dep);
+            versionsById.set(id, new Set([dep.version]));
+            continue;
+        }
+        versionsById.get(id)?.add(dep.version);
+        if (existing.version === dep.version) {
+            duplicates.push(dependencyRef(dep));
+        }
+    }
+    const conflicts = [];
+    for (const [id, versions] of versionsById.entries()) {
+        if (versions.size > 1) {
+            conflicts.push({ id, versions: [...versions].sort() });
+        }
+    }
+    return { dependencies: deduped, duplicates, conflicts };
+}
+function buildOrchestrationCustomTools(dependencies) {
+    const usedNames = new Set();
+    return dependencies.map((dep) => {
+        return {
+            name: nextUniqueToolName(dep, usedNames),
+            description: summarizeDependencyDescription(dep),
+            input_schema: normalizeToolInputSchema(dep.inputSchema),
+            command: `python3 /home/user/helpers/orch_call.py ${dependencyRef(dep)}`,
+        };
+    });
+}
+function buildOrchestrationManifest(args) {
+    const maxTurns = args.maxTurns ?? DEFAULT_MAX_TURNS;
+    const timeoutMs = args.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const maxHops = args.maxHops ?? defaultMaxHops(args.dependencies.length);
+    const perCallDownstreamCap = args.perCallDownstreamCap ?? DEFAULT_PER_CALL_DOWNSTREAM_CAP;
+    return {
+        name: args.name,
+        type: 'agent',
+        description: `Managed-loop orchestrator that coordinates ${args.dependencies.length} dependency agents`,
+        run_mode: 'on_demand',
+        tags: ['orchestration'],
+        supported_providers: ['any'],
+        required_secrets: [],
+        max_turns: maxTurns,
+        custom_tools: args.customTools,
+        // Keep loop in sync with top-level compatibility fields for local + cloud parity.
+        loop: {
+            max_turns: maxTurns,
+            custom_tools: args.customTools,
+        },
+        manifest: {
+            manifest_version: 1,
+            dependencies: args.dependencies.map((dep) => ({
+                id: `${dep.org}/${dep.name}`,
+                version: dep.version,
+            })),
+            max_hops: maxHops,
+            timeout_ms: timeoutMs,
+            per_call_downstream_cap: perCallDownstreamCap,
+        },
+    };
+}
+function buildOrchestrationPrompt(args) {
+    const toolLines = args.customTools.map((tool, idx) => {
+        const dep = args.dependencies[idx];
+        const description = dep.description?.trim() ? ` — ${dep.description.trim()}` : '';
+        return `- \`${tool.name}\` -> \`${dependencyRef(dep)}\`${description}`;
+    });
+    return [
+        `You are ${args.name}, an orchestration agent that delegates work to specialist dependency agents.`,
+        '',
+        'Primary objective:',
+        '- Use the dependency tools to solve the incoming task with accurate, well-structured results.',
+        '',
+        'Available dependency tools:',
+        ...toolLines,
+        '',
+        'Operating rules:',
+        '1. Prefer the dependency tools over ad-hoc bash implementations when a dependency can handle the task.',
+        '2. Pass only relevant fields to each tool call; do not invent required fields.',
+        '3. Chain tool calls when needed and reconcile conflicting outputs before finalizing.',
+        '4. If a dependency fails, retry once with corrected input; if still failing, return a clear partial result with the failure reason.',
+        '5. Always finish by calling submit_result with output that matches schema.json.',
+        '',
+        'Input template:',
+        '- `{{task}}`: the user task you must complete.',
+        '',
+        'Use concise, factual language in the final response.',
+        '',
+    ].join('\n');
+}
+function buildOrchestrationSchema() {
+    return {
+        input: {
+            type: 'object',
+            properties: {
+                task: {
+                    type: 'string',
+                    description: 'Task to delegate across dependency agents',
+                },
+                context: {
+                    type: 'object',
+                    description: 'Optional context payload forwarded to dependency tools as needed',
+                    additionalProperties: true,
+                },
+            },
+            required: ['task'],
+        },
+        output: {
+            type: 'object',
+            properties: {
+                result: {
+                    type: 'string',
+                    description: 'Final synthesized answer for the task',
+                },
+                used_tools: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Dependency tool names used to produce the result',
+                },
+                notes: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Warnings, fallbacks, or caveats encountered during orchestration',
+                },
+            },
+            required: ['result', 'used_tools'],
+        },
+    };
+}