@agentuity/cli 2.0.11 → 2.0.13

package/src/cmd/coder/workspace/update.ts

@@ -0,0 +1,154 @@
+import { z } from 'zod';
+import { APIError, ValidationInputError, ValidationOutputError } from '@agentuity/core';
+import {
+	CoderClient,
+	CoderUpdateWorkspaceRequestSchema,
+	type CoderUpdateWorkspaceRequest,
+} from '@agentuity/core/coder';
+import { createSubcommand } from '../../../types';
+import * as tui from '../../../tui';
+import { getCommand } from '../../../command-prefix';
+import { ErrorCode } from '../../../errors';
+import { resolveGitHubRepo } from '../resolve-repo';
+import {
+	formatWorkspaceValidationMessage,
+	hasWorkspaceUpdate,
+	parseCommaList,
+	printWorkspaceSummary,
+	readSetupScript,
+} from './common';
+
+export const updateWorkspaceSubcommand = createSubcommand({
+	name: 'update',
+	aliases: ['edit', 'patch'],
+	description: 'Update a Coder workspace',
+	tags: ['mutating', 'requires-auth'],
+	requires: { auth: true, org: true },
+	examples: [
+		{
+			command: getCommand('coder workspace update ws_abc123 --dependency git,nodejs'),
+			description: 'Update workspace dependencies',
+		},
+		{
+			command: getCommand('coder workspace update ws_abc123 --setup-script-file ./setup.sh'),
+			description: 'Update the workspace setup script',
+		},
+	],
+	schema: {
+		args: z.object({
+			workspaceId: z.string().describe('Workspace ID to update'),
+		}),
+		options: z.object({
+			url: z.string().optional().describe('Coder API URL override'),
+			name: z.string().optional().describe('Workspace name'),
+			description: z.string().optional().describe('Workspace description'),
+			scope: z.string().optional().describe('Workspace scope: user or org'),
+			repo: z.string().optional().describe('Repository URL to set'),
+			repoBranch: z.string().optional().describe('Branch for the repository'),
+			dependency: z
+				.string()
+				.optional()
+				.describe('Comma-separated APT dependencies to install into workspace snapshots'),
+			setupScript: z
+				.string()
+				.optional()
+				.describe('Inline shell script to run while preparing workspace snapshots'),
+			setupScriptFile: z
+				.string()
+				.optional()
+				.describe('Path to a shell script to run while preparing workspace snapshots'),
+			enabledAgents: z
+				.string()
+				.optional()
+				.describe('Comma-separated built-in/custom agents to include'),
+		}),
+	},
+	async handler(ctx) {
+		const { args, opts, options } = ctx;
+		const client = new CoderClient({
+			apiKey: ctx.auth.apiKey,
+			url: opts?.url,
+			orgId: ctx.orgId,
+		});
+
+		const body: CoderUpdateWorkspaceRequest = {
+			...(opts?.name && { name: opts.name }),
+			...(opts?.description && { description: opts.description }),
+			...(opts?.scope && { scope: opts.scope as 'user' | 'org' }),
+		};
+
+		if (opts?.repo) {
+			if (!options.json) tui.output('Resolving repository...');
+			try {
+				const resolved = await resolveGitHubRepo(client, opts.repo, opts?.repoBranch);
+				body.repos = [resolved];
+			} catch (err) {
+				const msg = err instanceof Error ? err.message : String(err);
+				tui.fatal(`Failed to resolve repository: ${msg}`, ErrorCode.VALIDATION_FAILED);
+				return;
+			}
+		}
+		if (opts?.dependency) {
+			body.dependencies = parseCommaList(opts.dependency);
+		}
+		try {
+			const setupScript = await readSetupScript({
+				setupScript: opts?.setupScript,
+				setupScriptFile: opts?.setupScriptFile,
+			});
+			if (setupScript !== undefined) body.setupScript = setupScript;
+		} catch (err) {
+			const msg = err instanceof Error ? err.message : String(err);
+			tui.fatal(`Failed to read setup script: ${msg}`, ErrorCode.VALIDATION_FAILED);
+			return;
+		}
+		if (opts?.enabledAgents) {
+			body.enabledAgents = parseCommaList(opts.enabledAgents);
+		}
+		if (!hasWorkspaceUpdate(body)) {
+			tui.fatal(
+				'Failed to update workspace: At least one field must be provided.',
+				ErrorCode.VALIDATION_FAILED
+			);
+		}
+
+		const validationResult = CoderUpdateWorkspaceRequestSchema.safeParse(body);
+		if (!validationResult.success) {
+			ctx.logger.trace(
+				'Validation issues: %s',
+				JSON.stringify(validationResult.error.issues, null, 2)
+			);
+			tui.fatal(
+				`Failed to update workspace: ${formatWorkspaceValidationMessage(validationResult.error.issues)}`,
+				ErrorCode.VALIDATION_FAILED
+			);
+		}
+
+		try {
+			const updated = await client.updateWorkspace(args.workspaceId, validationResult.data);
+
+			if (options.json) {
+				return updated;
+			}
+
+			tui.success(`Workspace ${updated.id} updated.`);
+			tui.newline();
+			printWorkspaceSummary(updated);
+			return updated;
+		} catch (err) {
+			if (err instanceof ValidationInputError || err instanceof ValidationOutputError) {
+				ctx.logger.trace('Validation response URL: %s', err.url ?? 'unknown');
+				ctx.logger.trace('Validation issues: %s', JSON.stringify(err.issues, null, 2));
+				tui.fatal(
+					`Failed to update workspace: ${formatWorkspaceValidationMessage(err.issues)}`,
+					ErrorCode.VALIDATION_FAILED
+				);
+			}
+			if (err instanceof APIError && err.status >= 400 && err.status < 500) {
+				tui.fatal(`Failed to update workspace: ${err.message}`, ErrorCode.VALIDATION_FAILED);
+			}
+			const msg = err instanceof Error ? err.message : String(err);
+			tui.fatal(`Failed to update workspace: ${msg}`, ErrorCode.NETWORK_ERROR);
+		}
+	},
+});

package/src/cmd/coder/workspace/validate-dependencies.ts

@@ -0,0 +1,75 @@
+import { z } from 'zod';
+import { APIError, ValidationOutputError } from '@agentuity/core';
+import { CoderClient } from '@agentuity/core/coder';
+import { createSubcommand } from '../../../types';
+import * as tui from '../../../tui';
+import { getCommand } from '../../../command-prefix';
+import { ErrorCode } from '../../../errors';
+import { parseCommaList } from './common';
+
+export const validateWorkspaceDependenciesSubcommand = createSubcommand({
+	name: 'validate-dependencies',
+	aliases: ['validate-deps'],
+	description: 'Validate APT dependencies for Coder workspace snapshots',
+	tags: ['read-only', 'requires-auth'],
+	idempotent: true,
+	requires: { auth: true, org: true },
+	examples: [
+		{
+			command: getCommand('coder workspace validate-dependencies git,nodejs'),
+			description: 'Validate dependency package names',
+		},
+	],
+	schema: {
+		args: z.object({
+			dependencies: z.string().describe('Comma-separated APT dependencies to validate'),
+		}),
+		options: z.object({
+			url: z.string().optional().describe('Coder API URL override'),
+		}),
+	},
+	async handler(ctx) {
+		const { args, opts, options } = ctx;
+		const dependencies = parseCommaList(args.dependencies);
+		if (dependencies.length === 0) {
+			tui.fatal('At least one dependency is required.', ErrorCode.VALIDATION_FAILED);
+		}
+
+		const client = new CoderClient({
+			apiKey: ctx.auth.apiKey,
+			url: opts?.url,
+			orgId: ctx.orgId,
+		});
+
+		try {
+			const result = await client.validateWorkspaceDependencies(dependencies);
+			if (options.json) {
+				return result;
+			}
+
+			if (result.valid.length > 0) {
+				tui.success(`Valid dependencies: ${result.valid.join(', ')}`);
+			}
+			if (result.invalid.length > 0) {
+				tui.error(`Invalid dependencies: ${result.invalid.length}`);
+				for (const invalid of result.invalid) {
+					tui.output(`  - ${invalid.package}: ${invalid.error}`);
+				}
+			}
+			return result;
+		} catch (err) {
+			if (err instanceof ValidationOutputError) {
+				ctx.logger.trace('Validation response URL: %s', err.url ?? 'unknown');
+				ctx.logger.trace('Validation issues: %s', JSON.stringify(err.issues, null, 2));
+			}
+			if (err instanceof APIError && err.status >= 400 && err.status < 500) {
+				tui.fatal(
+					`Failed to validate dependencies: ${err.message}`,
+					ErrorCode.VALIDATION_FAILED
+				);
+			}
+			const msg = err instanceof Error ? err.message : String(err);
+			tui.fatal(`Failed to validate dependencies: ${msg}`, ErrorCode.NETWORK_ERROR);
+		}
+	},
+});

package/src/cmd/dev/dev-lock.ts

@@ -71,35 +71,69 @@ function pidExists(pid: number): boolean {
 }
 
 /**
- * Kill a process by PID with SIGTERM, then SIGKILL if still alive
+ * Send a signal to a process group (negative PID) with fallback to direct PID.
+ * Returns true if the signal was sent successfully.
  */
-async function killPid(pid: number, logger: LoggerLike): Promise<void> {
-	if (!pidExists(pid)) return;
+function killProcessTree(pid: number, signal: NodeJS.Signals, logger: LoggerLike): boolean {
+	// Safety: never send signals to PID 0 (own process group), PID 1 (init/systemd),
+	// or other dangerously low PIDs. process.kill(-1) would signal every process
+	// the user owns, which would crash the entire desktop session.
+	if (pid <= 1) {
+		logger.debug('Refusing to kill dangerous pid %d, skipping process tree kill', pid);
+		return false;
+	}
 
+	// Try process group kill first (kills all children too)
 	try {
-		process.kill(pid, 'SIGTERM');
-		logger.debug('Sent SIGTERM to pid %d', pid);
+		process.kill(-pid, signal);
+		logger.debug('Sent %s to process group -%d', signal, pid);
+		return true;
 	} catch (err: unknown) {
 		const error = err as NodeJS.ErrnoException;
-		if (error.code === 'ESRCH') return;
-		logger.debug('Error sending SIGTERM to pid %d: %s', pid, error.message);
+		if (error.code !== 'ESRCH') {
+			logger.debug(
+				'Process group kill failed for pid %d (%s), falling back to direct',
+				pid,
+				error.code
+			);
+		}
 	}
 
-	// Give it a moment to exit gracefully
-	await new Promise((r) => setTimeout(r, 500));
-
-	if (!pidExists(pid)) return;
-
-	// Force kill
+	// Fall back to direct PID kill
 	try {
-		process.kill(pid, 'SIGKILL');
-		logger.debug('Sent SIGKILL to pid %d', pid);
+		process.kill(pid, signal);
+		logger.debug('Sent %s to pid %d (direct)', signal, pid);
+		return true;
 	} catch (err: unknown) {
 		const error = err as NodeJS.ErrnoException;
 		if (error.code !== 'ESRCH') {
-			logger.debug('Error sending SIGKILL to pid %d: %s', pid, error.message);
+			logger.debug('Direct kill failed for pid %d: %s', pid, error.code);
 		}
+		return false;
 	}
+}
+
+/**
+ * Kill a process by PID with SIGTERM, then SIGKILL if still alive.
+ * Targets the entire process tree to prevent orphaned child processes.
+ */
+async function killPid(pid: number, logger: LoggerLike): Promise<void> {
+	if (!pidExists(pid)) return;
+
+	// Send SIGTERM to process tree
+	const sent = killProcessTree(pid, 'SIGTERM', logger);
+	if (!sent) return;
+
+	// Give it a moment to exit gracefully
+	await new Promise((r) => setTimeout(r, 500));
+
+	// Always attempt SIGKILL on the process tree even if the leader has exited.
+	// On Unix, process groups persist after the leader exits and signaling via
+	// negative PGID still reaches remaining members. killProcessTree() handles
+	// ESRCH gracefully if the group no longer exists.
+
+	// Force kill the entire process tree
+	killProcessTree(pid, 'SIGKILL', logger);
 
 	// Wait for process to fully terminate
 	await new Promise((r) => setTimeout(r, 100));