@hunsu/bridge 0.1.3 → 0.2.0-next.1

package/package.json

@@ -1,24 +1,29 @@
 {
   "name": "@hunsu/bridge",
-  "version": "0.1.3",
+  "version": "0.2.0-next.1",
   "private": false,
-  "description": "Hunsu Bridge localhost runtime and Studio API server.",
+  "description": "Headless Hunsu Bridge daemon, authenticated CLI, and local Web API.",
   "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/lhj6102/hunsu.git",
+    "directory": "apps/bridge"
+  },
   "type": "module",
   "bin": {
     "hunsu-bridge": "./dist/cli.js"
   },
   "exports": {
     ".": {
-      "development": "./src/index.ts",
-      "types": "./src/index.ts",
+      "types": "./dist/index.d.ts",
       "import": "./dist/index.js",
       "default": "./dist/index.js"
     }
   },
   "files": [
     "dist",
-    "src"
+    "README.md",
+    "LICENSE"
   ],
   "publishConfig": {
     "access": "public"
@@ -26,17 +31,19 @@
   "engines": {
     "node": ">=22.18"
   },
-  "dependencies": {
+  "devDependencies": {
+    "esbuild": "0.27.7",
     "@hunsu/codex-runner": "0.1.1",
+    "@hunsu/config": "0.1.1",
     "@hunsu/core": "0.1.1",
-    "@hunsu/protocol-registry": "0.1.1",
     "@hunsu/protocol": "0.1.1",
-    "@hunsu/config": "0.1.1"
+    "@hunsu/protocol-registry": "0.1.1"
   },
   "scripts": {
-    "dev": "node --watch src/index.ts",
+    "dev": "node --conditions=development src/cli.ts dev",
     "bridge": "node --conditions=development src/cli.ts",
-    "build": "tsc -p tsconfig.build.json",
+    "build": "node scripts/build.mjs",
+    "pack-smoke": "node scripts/pack-smoke.mjs",
     "typecheck": "tsc -p tsconfig.json --noEmit"
   }
 }

package/dist/cli.d.ts

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-export {};

package/dist/execute/execute-model.d.ts

@@ -1,50 +0,0 @@
-import type { CommitSha } from "@hunsu/core";
-import type { ExecutionPlan, PathId, Result, MemberPath } from "@hunsu/protocol";
-export type ExecuteOrchestrationErrorCode = "invalid_start_state" | "active_execute_exists" | "team_output_invalid" | "execution_plan_invalid" | "goal_evaluation_invalid" | "path_dependency_unmet" | "terminal_output_missing" | "max_attempts_exhausted" | "side_effect_failed";
-export type ExecuteOrchestrationError = {
-    code: ExecuteOrchestrationErrorCode;
-    message: string;
-    details?: unknown;
-};
-export type ExecuteStepResult<T> = Result<T, ExecuteOrchestrationError>;
-export type ExecutionPlanStepResult = {
-    type: "done";
-    terminalPath?: MemberPath;
-    finalResponse?: string;
-} | {
-    type: "next";
-    execution: ExecutionPlan;
-    terminalPath?: MemberPath;
-    finalResponse?: string;
-} | {
-    type: "fail";
-    reason: ExecuteOrchestrationError;
-    terminalPath?: MemberPath;
-    finalResponse?: string;
-};
-export type ExecuteRunStatus = "running" | "paused" | "arrived" | "accident" | "failed" | "discarded" | "finished" | "stopped";
-export type PathRunPlan = {
-    path: MemberPath;
-    dependencyPathIds: PathId[];
-    dependencyOutputs: string[];
-    isTerminal: boolean;
-};
-export type PathRunOutcome = {
-    pathId: PathId;
-    finalResponse: string;
-    commit: CommitSha;
-    parentCommit?: CommitSha;
-    treeChanged: boolean;
-};
-export type ExecuteLoopDecision = {
-    type: "run_team_planning";
-} | {
-    type: "run_member_path";
-    path: PathRunPlan;
-} | {
-    type: "record_accident";
-    reason: ExecuteOrchestrationError;
-};
-export declare function executeError(code: ExecuteOrchestrationErrorCode, message: string, details?: unknown): ExecuteOrchestrationError;
-export declare function executeErrorToError(error: ExecuteOrchestrationError): Error;
-export declare function unwrapExecuteResult<T>(result: ExecuteStepResult<T>): T;

package/dist/execute/execute-model.js

@@ -1,17 +0,0 @@
-export function executeError(code, message, details) {
-    return details === undefined ? { code, message } : { code, message, details };
-}
-export function executeErrorToError(error) {
-    const wrapped = new Error(error.message);
-    wrapped.name = `ExecuteOrchestrationError:${error.code}`;
-    if (error.details !== undefined) {
-        wrapped.details = error.details;
-    }
-    return wrapped;
-}
-export function unwrapExecuteResult(result) {
-    if (result.ok) {
-        return result.value;
-    }
-    throw executeErrorToError(result.error);
-}

package/dist/execute/execute-workflow.d.ts

@@ -1,27 +0,0 @@
-import { type BoardProjection, type Destination, type LineRecord, type NodeRecord, type PositiveInteger } from "@hunsu/protocol";
-import { type ExecuteRunStatus, type ExecuteLoopDecision, type ExecuteStepResult } from "./execute-model.ts";
-export type ExecuteStartExistingRun = {
-    sourceNodeId?: string;
-    status: ExecuteRunStatus;
-};
-export type ExecuteStartPlanInput = {
-    board: BoardProjection;
-    line: LineRecord;
-    lineNode: NodeRecord | undefined;
-    existingRuns: readonly ExecuteStartExistingRun[];
-    activeDestinations: readonly Destination[];
-    selectedDestinationIds?: readonly string[];
-    formatMovePosition?: (node: NodeRecord) => string;
-};
-export type ExecuteStartPlan = {
-    lineNode: NodeRecord;
-    selectedDestinationIds: string[];
-    targetMoveOrdinal: PositiveInteger;
-};
-export declare function planExecuteStart(input: ExecuteStartPlanInput): ExecuteStepResult<ExecuteStartPlan>;
-export declare function ensureTerminalOutput(finalResponse: string | undefined): ExecuteStepResult<string>;
-export declare function planMaxAttemptsExceeded(input: {
-    maxAttemptCount: PositiveInteger;
-}): Extract<ExecuteLoopDecision, {
-    type: "record_accident";
-}>;

package/dist/execute/execute-workflow.js

@@ -1,65 +0,0 @@
-import { err, makePositiveInteger, ok } from "@hunsu/protocol";
-import { executeError } from "./execute-model.js";
-export function planExecuteStart(input) {
-    const { line, lineNode } = input;
-    if (!lineNode) {
-        return err(executeError("invalid_start_state", `No execute-ready MOVE found for Team route ${line.id}`));
-    }
-    if (line.status === "failed" || line.status === "complete" || line.status === "abandoned") {
-        return err(executeError("invalid_start_state", `Cannot start Execute from ${line.id} because the route is ${line.status}`));
-    }
-    const nodesWithNextMove = new Set(input.board.edges.filter(edge => edge.type === "move").map(edge => edge.fromNodeId));
-    if (nodesWithNextMove.has(lineNode.id)) {
-        return err(executeError("invalid_start_state", `Cannot start Execute from ${formatMovePosition(lineNode, input.formatMovePosition)} because Arrived or Accident already exists`));
-    }
-    const activeRun = input.existingRuns.find(existing => existing.sourceNodeId === lineNode.id && (existing.status === "running" || existing.status === "paused"));
-    if (activeRun) {
-        return err(executeError("active_execute_exists", `A Execute is already active for ${formatMovePosition(lineNode, input.formatMovePosition)}`));
-    }
-    const targetMoveOrdinal = makePositiveInteger(lineNode.ordinal + 1, "targetMoveOrdinal");
-    if (!targetMoveOrdinal.ok) {
-        return err(executeError("invalid_start_state", targetMoveOrdinal.error.message));
-    }
-    const selectedDestinationIds = normalizeSelectedDestinationIds(input.selectedDestinationIds, input.activeDestinations);
-    if (!selectedDestinationIds.ok) {
-        return selectedDestinationIds;
-    }
-    return ok({
-        lineNode,
-        selectedDestinationIds: selectedDestinationIds.value,
-        targetMoveOrdinal: targetMoveOrdinal.value
-    });
-}
-export function ensureTerminalOutput(finalResponse) {
-    if (!finalResponse) {
-        return err(executeError("terminal_output_missing", "ExecutionPlan completed without a terminal output"));
-    }
-    return ok(finalResponse);
-}
-export function planMaxAttemptsExceeded(input) {
-    return {
-        type: "record_accident",
-        reason: executeError("max_attempts_exhausted", `Execute exceeded max attempt count ${input.maxAttemptCount} without recording an Arrived MOVE`, { maxAttemptCount: input.maxAttemptCount })
-    };
-}
-function normalizeSelectedDestinationIds(selectedDestinationIds, activeDestinations) {
-    const nextDestination = nextQueuedDestination(activeDestinations);
-    if (selectedDestinationIds && selectedDestinationIds.length > 0) {
-        if (selectedDestinationIds.length !== 1) {
-            return err(executeError("invalid_start_state", "Execute must select exactly one Destination"));
-        }
-        return nextDestination && selectedDestinationIds[0] === nextDestination.id
-            ? ok([...selectedDestinationIds])
-            : err(executeError("invalid_start_state", "Execute must select the next Destination in the queue"));
-    }
-    return ok(nextDestination ? [nextDestination.id] : []);
-}
-function nextQueuedDestination(activeDestinations) {
-    return [...activeDestinations].sort(destinationQueueSort)[0];
-}
-function destinationQueueSort(left, right) {
-    return (right.priority ?? 0) - (left.priority ?? 0);
-}
-function formatMovePosition(node, formatter) {
-    return formatter ? formatter(node) : `${node.teamName ?? "Team"} MOVE ${node.ordinal}`;
-}

package/dist/execute/execution-plan.d.ts

@@ -1,6 +0,0 @@
-import { type GoalEvaluation, type GoalExecutionPlan, type ExecutionPlan, type MemberPath, type QueueExecutionPlan } from "@hunsu/protocol";
-import { type ExecuteStepResult } from "./execute-model.ts";
-export declare function parseExecutionPlan(finalResponse: string): ExecuteStepResult<ExecutionPlan>;
-export declare function parseGoalEvaluation(finalResponse: string): ExecuteStepResult<GoalEvaluation>;
-export declare function memberPathForGoalRole(execution: GoalExecutionPlan, role: "assignee" | "evaluator", pathId: string, requires: MemberPath["requires"]): MemberPath;
-export declare function nextQueueExecution(queue: QueueExecutionPlan, headResult: ExecutionPlan | undefined): ExecutionPlan | undefined;

package/dist/execute/execution-plan.js

@@ -1,337 +0,0 @@
-import { err, makeNonEmptyText, makeNonNegativeInteger, ok } from "@hunsu/protocol";
-import { executeError } from "./execute-model.js";
-export function parseExecutionPlan(finalResponse) {
-    const parsed = parseJsonObject(finalResponse, "Team planning final response must be a JSON ExecutionPlan object");
-    if (!parsed.ok) {
-        return parsed;
-    }
-    return decodeExecutionPlan(parsed.value, "execution");
-}
-export function parseGoalEvaluation(finalResponse) {
-    const parsed = parseJsonObject(finalResponse, "Goal evaluator final response must be a JSON object");
-    if (!parsed.ok) {
-        return parsed;
-    }
-    const record = parsed.value;
-    if (record.type === "pass") {
-        if (typeof record.summary !== "string" || record.summary.trim() === "") {
-            return err(executeError("goal_evaluation_invalid", "pass evaluation must include a non-empty summary"));
-        }
-        const evidence = decodeOptionalStringArray(record.evidence, "evidence");
-        if (!evidence.ok) {
-            return evidence;
-        }
-        return ok({
-            type: "pass",
-            summary: record.summary,
-            evidence: evidence.value
-        });
-    }
-    if (record.type === "fail") {
-        if (typeof record.reason !== "string" || record.reason.trim() === "") {
-            return err(executeError("goal_evaluation_invalid", "fail evaluation must include a non-empty reason"));
-        }
-        if (typeof record.feedback !== "string" || record.feedback.trim() === "") {
-            return err(executeError("goal_evaluation_invalid", "fail evaluation must include non-empty feedback"));
-        }
-        if (record.nextGoal !== undefined && typeof record.nextGoal !== "string") {
-            return err(executeError("goal_evaluation_invalid", "fail evaluation nextGoal must be a string when present"));
-        }
-        const evidence = decodeOptionalStringArray(record.evidence, "evidence");
-        if (!evidence.ok) {
-            return evidence;
-        }
-        return ok({
-            type: "fail",
-            reason: record.reason,
-            feedback: record.feedback,
-            nextGoal: typeof record.nextGoal === "string" && record.nextGoal.trim() !== "" ? record.nextGoal : undefined,
-            evidence: evidence.value
-        });
-    }
-    return err(executeError("goal_evaluation_invalid", "Goal evaluator response type must be pass or fail"));
-}
-export function memberPathForGoalRole(execution, role, pathId, requires) {
-    if (role === "assignee") {
-        return {
-            id: pathId,
-            executorId: execution.assignee.executorId,
-            goal: execution.assignee.goal,
-            requires
-        };
-    }
-    const roleConfig = execution.evaluator;
-    if (!roleConfig) {
-        throw new Error(`Goal ${execution.id} does not define an evaluator`);
-    }
-    return {
-        id: pathId,
-        executorId: roleConfig.executorId,
-        goal: roleConfig.prompt,
-        requires
-    };
-}
-export function nextQueueExecution(queue, headResult) {
-    const [, ...tail] = queue.items;
-    if (headResult) {
-        return { ...queue, items: [headResult, ...tail] };
-    }
-    if (tail.length === 0) {
-        return undefined;
-    }
-    return { ...queue, items: tail };
-}
-function decodeExecutionPlan(value, path) {
-    if (!isRecord(value)) {
-        return err(executeError("execution_plan_invalid", `${path} must be an object`));
-    }
-    if (value.kind === "queue") {
-        return decodeQueueExecutionPlan(value, path);
-    }
-    if (value.kind === "goal") {
-        return decodeGoalExecutionPlan(value, path);
-    }
-    if (value.kind === "continuation") {
-        return decodeExecutionContinuation(value, path);
-    }
-    return err(executeError("execution_plan_invalid", `${path}.kind must be queue, goal, or continuation`));
-}
-function decodeQueueExecutionPlan(record, path) {
-    const id = decodeNonEmptyString(record.id, `${path}.id`);
-    if (!id.ok) {
-        return id;
-    }
-    if (!Array.isArray(record.items)) {
-        return err(executeError("execution_plan_invalid", `${path}.items must be an array`));
-    }
-    const items = [];
-    for (const [index, item] of record.items.entries()) {
-        const decoded = decodeExecutionPlan(item, `${path}.items[${index}]`);
-        if (!decoded.ok) {
-            return decoded;
-        }
-        items.push(decoded.value);
-    }
-    return ok({ kind: "queue", id: id.value, items });
-}
-function decodeGoalExecutionPlan(record, path) {
-    if (record.stage === "needs_evaluation") {
-        return decodeGoalPathEvaluationStage(record, path);
-    }
-    if (record.stage === "needs_execution") {
-        return decodeGoalExecutionPlanStage(record, path);
-    }
-    return err(executeError("execution_plan_invalid", `${path}.stage must be needs_evaluation or needs_execution`));
-}
-function decodeExecutionContinuation(record, path) {
-    const id = decodePathId(record.id, `${path}.id`);
-    if (!id.ok) {
-        return id;
-    }
-    const teamScopeId = decodeMemberId(record.teamScopeId, `${path}.teamScopeId`);
-    if (!teamScopeId.ok) {
-        return teamScopeId;
-    }
-    const execution = decodeExecutionPlan(record.execution, `${path}.execution`);
-    if (!execution.ok) {
-        return execution;
-    }
-    const continuation = record.continuation === undefined
-        ? ok(undefined)
-        : isRecord(record.continuation)
-            ? decodeGoalExecutionPlan(record.continuation, `${path}.continuation`)
-            : err(executeError("execution_plan_invalid", `${path}.continuation must be an object`));
-    if (!continuation.ok) {
-        return continuation;
-    }
-    return ok({
-        kind: "continuation",
-        id: id.value,
-        teamScopeId: teamScopeId.value,
-        execution: execution.value,
-        continuation: continuation.value
-    });
-}
-function decodeGoalPathEvaluationStage(record, path) {
-    const id = decodePathId(record.id, `${path}.id`);
-    if (!id.ok) {
-        return id;
-    }
-    const assignee = decodeGoalRole(record.assignee, `${path}.assignee`, "goal");
-    if (!assignee.ok) {
-        return assignee;
-    }
-    const evaluator = record.evaluator === undefined || record.evaluator === null ? ok(undefined) : decodeGoalRole(record.evaluator, `${path}.evaluator`, "prompt");
-    if (!evaluator.ok) {
-        return evaluator;
-    }
-    const remainingAttempts = makeNonNegativeInteger(record.remainingAttempts, `${path}.remainingAttempts`);
-    if (!remainingAttempts.ok) {
-        return err(executeError("execution_plan_invalid", remainingAttempts.error.message));
-    }
-    const requires = decodePathRequires(record.requires, `${path}.requires`);
-    if (!requires.ok) {
-        return requires;
-    }
-    return ok({
-        kind: "goal",
-        stage: "needs_evaluation",
-        id: id.value,
-        assignee: {
-            executorId: assignee.value.executorId,
-            goal: assignee.value.text
-        },
-        evaluator: evaluator.value
-            ? {
-                executorId: evaluator.value.executorId,
-                prompt: evaluator.value.text
-            }
-            : undefined,
-        remainingAttempts: remainingAttempts.value,
-        requires: requires.value
-    });
-}
-function decodeGoalExecutionPlanStage(record, path) {
-    const decoded = decodeGoalPathEvaluationStage({ ...record, stage: "needs_evaluation" }, path);
-    if (!decoded.ok) {
-        return decoded;
-    }
-    const evaluationPathId = decodePathId(record.evaluationPathId, `${path}.evaluationPathId`);
-    if (!evaluationPathId.ok) {
-        return evaluationPathId;
-    }
-    const evaluation = decodeFailGoalEvaluation(record.evaluation, `${path}.evaluation`);
-    if (!evaluation.ok) {
-        return evaluation;
-    }
-    if (!Array.isArray(record.requires)) {
-        return err(executeError("execution_plan_invalid", `${path}.requires must be an array for needs_execution`));
-    }
-    const requires = decodePathIdArray(record.requires, `${path}.requires`);
-    if (!requires.ok) {
-        return requires;
-    }
-    if (requires.value.length !== 1 || requires.value[0] !== evaluationPathId.value) {
-        return err(executeError("execution_plan_invalid", `${path}.requires must contain only ${path}.evaluationPathId`));
-    }
-    return ok({
-        ...decoded.value,
-        stage: "needs_execution",
-        evaluationPathId: evaluationPathId.value,
-        evaluation: evaluation.value,
-        requires: requires.value
-    });
-}
-function decodeGoalRole(value, path, textField) {
-    if (!isRecord(value)) {
-        return err(executeError("execution_plan_invalid", `${path} must be an object`));
-    }
-    const executorId = decodeMemberId(value.executorId, `${path}.executorId`);
-    if (!executorId.ok) {
-        return executorId;
-    }
-    const text = decodeNonEmptyString(value[textField], `${path}.${textField}`);
-    if (!text.ok) {
-        return text;
-    }
-    return ok({ executorId: executorId.value, text: text.value });
-}
-function decodeFailGoalEvaluation(value, path) {
-    if (!isRecord(value)) {
-        return err(executeError("execution_plan_invalid", `${path} must be an object`));
-    }
-    if (value.type !== "fail") {
-        return err(executeError("execution_plan_invalid", `${path}.type must be fail`));
-    }
-    if (typeof value.reason !== "string" || value.reason.trim() === "") {
-        return err(executeError("execution_plan_invalid", `${path}.reason must be a non-empty string`));
-    }
-    if (typeof value.feedback !== "string" || value.feedback.trim() === "") {
-        return err(executeError("execution_plan_invalid", `${path}.feedback must be a non-empty string`));
-    }
-    if (value.nextGoal !== undefined && typeof value.nextGoal !== "string") {
-        return err(executeError("execution_plan_invalid", `${path}.nextGoal must be a string when present`));
-    }
-    const evidence = decodeOptionalStringArray(value.evidence, `${path}.evidence`);
-    if (!evidence.ok) {
-        return evidence;
-    }
-    return ok({
-        type: "fail",
-        reason: value.reason,
-        feedback: value.feedback,
-        nextGoal: typeof value.nextGoal === "string" && value.nextGoal.trim() !== "" ? value.nextGoal : undefined,
-        evidence: evidence.value
-    });
-}
-function decodeNonEmptyString(value, path) {
-    if (typeof value !== "string" || value.trim() === "") {
-        return err(executeError("execution_plan_invalid", `${path} must be a non-empty string`));
-    }
-    return ok(value);
-}
-function decodePathId(value, path) {
-    const decoded = makeNonEmptyText(value, path);
-    if (!decoded.ok) {
-        return err(executeError("execution_plan_invalid", decoded.error.message));
-    }
-    return ok(decoded.value);
-}
-function decodeMemberId(value, path) {
-    const decoded = makeNonEmptyText(value, path);
-    if (!decoded.ok) {
-        return err(executeError("execution_plan_invalid", decoded.error.message));
-    }
-    return ok(decoded.value);
-}
-function decodePathRequires(value, path) {
-    if (value === "PrevMove") {
-        return ok("PrevMove");
-    }
-    return decodePathIdArray(value, path);
-}
-function decodePathIdArray(value, path) {
-    const decoded = decodeStringArray(value, path, "execution_plan_invalid");
-    if (!decoded.ok) {
-        return decoded;
-    }
-    const pathIds = [];
-    for (const [index, item] of decoded.value.entries()) {
-        const pathId = makeNonEmptyText(item, `${path}[${index}]`);
-        if (!pathId.ok) {
-            return err(executeError("execution_plan_invalid", pathId.error.message));
-        }
-        pathIds.push(pathId.value);
-    }
-    return ok(pathIds);
-}
-function decodeOptionalStringArray(value, path) {
-    if (value === undefined) {
-        return ok(undefined);
-    }
-    return decodeStringArray(value, path, "goal_evaluation_invalid");
-}
-function decodeStringArray(value, path, code) {
-    if (!Array.isArray(value)) {
-        return err(executeError(code, `${path} must be an array of strings`));
-    }
-    if (!value.every(item => typeof item === "string")) {
-        return err(executeError(code, `${path} must be an array of strings`));
-    }
-    return ok([...value]);
-}
-function parseJsonObject(text, errorMessage) {
-    try {
-        const parsed = JSON.parse(text);
-        if (!isRecord(parsed)) {
-            return err(executeError("execution_plan_invalid", errorMessage));
-        }
-        return ok(parsed);
-    }
-    catch (error) {
-        return err(executeError("execution_plan_invalid", errorMessage, { cause: error instanceof Error ? error.message : String(error) }));
-    }
-}
-function isRecord(value) {
-    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
-}

package/src/cli.ts

@@ -1,82 +0,0 @@
-#!/usr/bin/env node
-import { startStudioBridge } from "./index.ts";
-
-type ParsedArgs = {
-  command?: string;
-  flags: Map<string, string | boolean>;
-};
-
-async function main(argv = process.argv.slice(2)): Promise<number> {
-  const parsed = parseArgs(argv);
-  if (parsed.command === "help" || hasFlag(parsed, "help")) {
-    printHelp();
-    return 0;
-  }
-  if (parsed.command && parsed.command !== "start" && parsed.command !== "studio") {
-    throw new Error(`Unknown command: ${parsed.command}`);
-  }
-
-  await startStudioBridge({
-    cwd: getFlag(parsed, "cwd") ?? process.cwd(),
-    webUrl: getFlag(parsed, "web-url"),
-    noOpen: hasFlag(parsed, "no-open"),
-    dryRun: hasFlag(parsed, "dry-run"),
-    json: hasFlag(parsed, "json")
-  });
-  return 0;
-}
-
-function parseArgs(argv: string[]): ParsedArgs {
-  const flags = new Map<string, string | boolean>();
-  let command: string | undefined;
-  for (let index = 0; index < argv.length; index += 1) {
-    const token = argv[index];
-    if (!token.startsWith("--")) {
-      command ??= token;
-      continue;
-    }
-    const rawName = token.slice(2);
-    const equalsIndex = rawName.indexOf("=");
-    if (equalsIndex >= 0) {
-      flags.set(rawName.slice(0, equalsIndex), rawName.slice(equalsIndex + 1));
-      continue;
-    }
-    const next = argv[index + 1];
-    if (next && !next.startsWith("--")) {
-      flags.set(rawName, next);
-      index += 1;
-      continue;
-    }
-    flags.set(rawName, true);
-  }
-  return { command, flags };
-}
-
-function getFlag(parsed: ParsedArgs, name: string): string | undefined {
-  const value = parsed.flags.get(name);
-  return typeof value === "string" ? value : undefined;
-}
-
-function hasFlag(parsed: ParsedArgs, name: string): boolean {
-  return parsed.flags.get(name) === true;
-}
-
-function printHelp(): void {
-  console.log(`Usage: hunsu-bridge [start|studio] [options]
-
-Options:
-  --cwd <path>       Repository or workspace path to open. Defaults to the current directory.
-  --web-url <url>    Studio URL to pair with. Defaults to HUNSU_WEB_URL or https://hunsu.app/studio.
-  --no-open          Print the paired Studio URL without opening a browser.
-  --dry-run          Print start information without starting the Bridge server.
-  --json             Print start information as JSON.
-  --help             Show this help.
-`);
-}
-
-main().then(code => {
-  process.exitCode = code;
-}).catch(error => {
-  console.error(error instanceof Error ? error.message : String(error));
-  process.exitCode = 1;
-});