ainecto 0.13.1 → 0.14.0-next.1

package/dist/bin/ainecto.js

@@ -25,9 +25,9 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
-// node_modules/@xterm/addon-serialize/lib/addon-serialize.js
+// ../ainecto-cli/node_modules/@xterm/addon-serialize/lib/addon-serialize.js
 var require_addon_serialize = __commonJS({
-  "node_modules/@xterm/addon-serialize/lib/addon-serialize.js"(exports, module) {
+  "../ainecto-cli/node_modules/@xterm/addon-serialize/lib/addon-serialize.js"(exports, module) {
     "use strict";
     !(function(t, e) {
       "object" == typeof exports && "object" == typeof module ? module.exports = e() : "function" == typeof define && define.amd ? define([], e) : "object" == typeof exports ? exports.SerializeAddon = e() : t.SerializeAddon = e();
@@ -391,9 +391,9 @@ var require_addon_serialize = __commonJS({
   }
 });
 
-// node_modules/@xterm/headless/lib-headless/xterm-headless.js
+// ../ainecto-cli/node_modules/@xterm/headless/lib-headless/xterm-headless.js
 var require_xterm_headless = __commonJS({
-  "node_modules/@xterm/headless/lib-headless/xterm-headless.js"(exports) {
+  "../ainecto-cli/node_modules/@xterm/headless/lib-headless/xterm-headless.js"(exports) {
     "use strict";
     (() => {
       "use strict";
@@ -5585,8 +5585,8 @@ function assertLoopbackRedirectUrl(value) {
   }
   throw new Error("OAuth redirect URI must be an http localhost loopback URL.");
 }
-function isLoopbackHostname(hostname) {
-  return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "::1" || hostname === "[::1]";
+function isLoopbackHostname(hostname2) {
+  return hostname2 === "localhost" || hostname2 === "127.0.0.1" || hostname2 === "::1" || hostname2 === "[::1]";
 }
 function assertEnv(value) {
   if (value === void 0) {
@@ -5678,7 +5678,7 @@ function legacyRoleInput(flag, envVars = process.env) {
 
 // src/core/version.ts
 var UNBUNDLED_VERSION = "dev";
-var CLI_VERSION = true ? "0.13.1" : UNBUNDLED_VERSION;
+var CLI_VERSION = true ? "0.14.0-next.1" : UNBUNDLED_VERSION;
 var PACKAGE_NAME = "@ainecto/mcp";
 var CLI_USER_AGENT = `${PACKAGE_NAME} ${CLI_VERSION}`;
 function bridgePackageSpec(version = CLI_VERSION) {
@@ -12562,8 +12562,735 @@ function restoreSummary(data) {
   return parts.length ? parts.join("\n") : "Nothing to restore.";
 }
 
-// src/adapters/cli/ainectoCli.ts
+// src/adapters/cli/agentCommand.ts
+import { spawnSync } from "child_process";
+import { hostname } from "os";
+
+// src/core/agent/claudeArgs.ts
+function agentReplySchema(textMaxCharacters) {
+  return {
+    type: "object",
+    additionalProperties: false,
+    required: ["reply"],
+    properties: { reply: { type: "string", minLength: 1, maxLength: textMaxCharacters } }
+  };
+}
+function agentMcpConfig(nodePath, cliScript, endpoint) {
+  return { mcpServers: { ainecto: { command: nodePath, args: [cliScript, "--endpoint", endpoint, "mcp"] } } };
+}
+function claudeAgentArgs(input) {
+  const args = [
+    "-p",
+    "--input-format",
+    "stream-json",
+    "--output-format",
+    "stream-json",
+    "--verbose",
+    "--json-schema",
+    JSON.stringify(input.schema),
+    "--tools",
+    "",
+    // 내장 도구(Bash·Read·Write·Edit·Agent·Skill·WebFetch…) 전부 끔
+    "--strict-mcp-config",
+    "--mcp-config",
+    JSON.stringify(input.mcpConfig),
+    "--allowedTools",
+    "mcp__ainecto",
+    "--permission-mode",
+    "dontAsk",
+    // 허용 밖은 묻지 않고 바로 거절(헤드리스에서 묻기 = 2분 대기)
+    "--setting-sources",
+    ""
+    // 사용자·프로젝트 설정(플러그인·스킬·훅·권한) 끔
+  ];
+  if (input.resumeSessionId) {
+    args.push("--resume", input.resumeSessionId);
+  }
+  return args;
+}
+function claudeAgentEnv(env) {
+  const out = { ...env };
+  delete out.AINECTO_TOKEN;
+  return out;
+}
+var AINECTO_TOOL_PREFIX = "mcp__ainecto__";
+
+// src/core/agent/claudeProcess.ts
+import { spawn as spawn4 } from "child_process";
+import { createInterface as createInterface3 } from "readline";
+
+// src/core/agent/documents.ts
+var DOCUMENT_LINE = /📄[^\n]*?\/app\/docs\/([0-9a-f]{32})(?![0-9a-f])/gu;
+function documentUuidsIn(content) {
+  const out = [];
+  for (const text of texts(content)) {
+    for (const match of text.matchAll(DOCUMENT_LINE)) {
+      const uuid = match[1];
+      if (uuid && !out.includes(uuid)) out.push(uuid);
+    }
+  }
+  return out;
+}
+function texts(content) {
+  if (typeof content === "string") return [content];
+  if (!Array.isArray(content)) return [];
+  return content.flatMap((part) => part && typeof part === "object" && typeof part.text === "string" ? [part.text] : []);
+}
+function writeToolNames(tools) {
+  return new Set(tools.filter((tool) => tool.annotations?.readOnlyHint !== true).map((tool) => tool.name));
+}
+
+// src/core/agent/limits.ts
+var AGENT_CALL_TIMEOUT_MS = 1e4;
+var AGENT_RETRY_MIN_MS = 500;
+var AGENT_RETRY_MAX_MS = 1e4;
+var AGENT_TURN_TIMEOUT_MS = 15 * 6e4;
+var AGENT_STOP_WAIT_MS = 5e3;
+function nextRetryDelay(previousMs) {
+  if (previousMs === void 0) return AGENT_RETRY_MIN_MS;
+  return Math.min(previousMs * 2, AGENT_RETRY_MAX_MS);
+}
+
+// src/core/agent/claudeProcess.ts
+var spawnClaude = (args, options) => spawn4("claude", args, { cwd: options.cwd, env: options.env, stdio: ["pipe", "pipe", "pipe"] });
+var ClaudeAgentProcess = class {
+  constructor(conversationUuid, resumed, args, options) {
+    this.conversationUuid = conversationUuid;
+    this.resumed = resumed;
+    this.sessionId = void 0;
+    this.child = options.spawnImpl(args, { cwd: options.cwd, env: options.env });
+    const pid = this.child.pid ?? -1;
+    options.log.write({ event: "process_start", pid, conversationUuid, resume: resumed });
+    this.child.stderr.setEncoding("utf8");
+    this.child.stderr.on("data", (chunk) => {
+      this.stderrTail = (this.stderrTail + chunk).slice(-2e3);
+    });
+    this.exited = new Promise((resolve4) => {
+      const done = (code, signal) => {
+        if (this.exitInfo) return;
+        this.exitInfo = { code, signal };
+        options.log.write({ event: "process_exit", pid, conversationUuid, code, signal });
+        this.finish({ kind: "exited", code, signal, stderrTail: this.stderrTail.trim().slice(-500) });
+        resolve4();
+      };
+      this.child.on("exit", done);
+      this.child.on("error", (error) => {
+        this.stderrTail += `
+${error.message}`;
+        done(null, null);
+      });
+    });
+    this.child.stdin.on("error", () => {
+    });
+    createInterface3({ input: this.child.stdout }).on("line", (line) => {
+      let event;
+      try {
+        event = JSON.parse(line);
+      } catch {
+        options.log.write({ event: "bad_line", pid, length: line.length });
+        return;
+      }
+      this.onEvent(event, options.writeTools);
+    });
+  }
+  conversationUuid;
+  resumed;
+  sessionId;
+  child;
+  toolNames = /* @__PURE__ */ new Map();
+  pending;
+  stderrTail = "";
+  exitInfo;
+  exited;
+  get pid() {
+    return this.child.pid ?? -1;
+  }
+  get alive() {
+    return this.exitInfo === void 0;
+  }
+  /** 한 차례 — 기한 안에 result 가 오지 않으면 «timeout»(프로세스는 부른 쪽이 내린다). */
+  async runTurn(text, timeoutMs) {
+    if (!this.alive) {
+      return { kind: "exited", code: this.exitInfo?.code ?? null, signal: this.exitInfo?.signal ?? null, stderrTail: this.stderrTail.trim().slice(-500) };
+    }
+    const outcome = new Promise((resolve4) => {
+      this.pending = { resolve: resolve4, documents: [] };
+    });
+    this.child.stdin.write(`${JSON.stringify({ type: "user", message: { role: "user", content: text } })}
+`);
+    let timer;
+    const timeout = new Promise((resolve4) => {
+      timer = setTimeout(() => resolve4({ kind: "timeout" }), timeoutMs);
+    });
+    try {
+      return await Promise.race([outcome, timeout]);
+    } finally {
+      clearTimeout(timer);
+      this.pending = void 0;
+    }
+  }
+  /** stdin 닫기 → B6 → SIGTERM → B6 → SIGKILL. */
+  async stop() {
+    if (!this.alive) return;
+    this.child.stdin.end();
+    if (await this.waitExit(AGENT_STOP_WAIT_MS)) return;
+    this.child.kill("SIGTERM");
+    if (await this.waitExit(AGENT_STOP_WAIT_MS)) return;
+    this.child.kill("SIGKILL");
+    await this.waitExit(AGENT_STOP_WAIT_MS);
+  }
+  async waitExit(ms) {
+    let timer;
+    const timedOut = new Promise((resolve4) => {
+      timer = setTimeout(() => resolve4(false), ms);
+    });
+    try {
+      return await Promise.race([this.exited.then(() => true), timedOut]);
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  finish(outcome) {
+    const pending = this.pending;
+    this.pending = void 0;
+    pending?.resolve(outcome);
+  }
+  onEvent(event, writeTools) {
+    if (event.type === "system" && event.subtype === "init" && typeof event.session_id === "string") {
+      this.sessionId = event.session_id;
+      return;
+    }
+    const content = event.message?.content;
+    if (event.type === "assistant" && Array.isArray(content)) {
+      for (const part of content) {
+        if (part.type === "tool_use" && typeof part.id === "string" && typeof part.name === "string") {
+          this.toolNames.set(part.id, part.name);
+        }
+      }
+      return;
+    }
+    if (event.type === "user" && Array.isArray(content) && this.pending) {
+      for (const part of content) {
+        if (part.type !== "tool_result" || typeof part.tool_use_id !== "string") continue;
+        const name = this.toolNames.get(part.tool_use_id);
+        if (!name?.startsWith(AINECTO_TOOL_PREFIX) || !writeTools.has(name.slice(AINECTO_TOOL_PREFIX.length))) continue;
+        for (const uuid of documentUuidsIn(part.content)) {
+          if (!this.pending.documents.includes(uuid)) this.pending.documents.push(uuid);
+        }
+      }
+      return;
+    }
+    if (event.type === "result") {
+      if (typeof event.session_id === "string") this.sessionId = event.session_id;
+      const documents = this.pending?.documents ?? [];
+      this.finish({
+        kind: "result",
+        documents,
+        result: {
+          subtype: typeof event.subtype === "string" ? event.subtype : void 0,
+          isError: event.is_error === true,
+          structuredOutput: event.structured_output,
+          resultText: typeof event.result === "string" ? event.result : void 0,
+          sessionId: this.sessionId,
+          numTurns: typeof event.num_turns === "number" ? event.num_turns : void 0,
+          costUsd: typeof event.total_cost_usd === "number" ? event.total_cost_usd : void 0
+        }
+      });
+    }
+  }
+};
+
+// src/core/agent/http.ts
+import { randomUUID as randomUUID2 } from "crypto";
+var AgentCallError = class extends Error {
+  constructor(message, op, status, code) {
+    super(message);
+    this.op = op;
+    this.status = status;
+    this.code = code;
+    this.name = "AgentCallError";
+  }
+  op;
+  status;
+  code;
+  /** 다시 해 볼 만한가 — 네트워크·기한·5xx·429. */
+  get retryable() {
+    return this.status === void 0 || this.status >= 500 || this.status === 429;
+  }
+};
+function createAgentHttp(input) {
+  const fetchImpl = input.fetchImpl ?? fetch;
+  const base = `${input.endpoint.replace(/\/+$/, "")}/agent/pc/`;
+  let linkToken;
+  async function send(op, payload, token, options) {
+    const controller = new AbortController();
+    const timer = setTimeout(
+      () => controller.abort(new DOMException("timed out", "TimeoutError")),
+      (options.holdMs ?? 0) + AGENT_CALL_TIMEOUT_MS
+    );
+    const onStop = () => controller.abort(new DOMException("stopped", "AbortError"));
+    options.signal?.addEventListener("abort", onStop, { once: true });
+    const headers = { "Content-Type": "application/json", Accept: "application/json" };
+    if (token) headers.Authorization = `Bearer ${token}`;
+    if (linkToken && op !== "open") headers["X-Link-Token"] = linkToken;
+    try {
+      const response = await fetchImpl(base + op, { method: "POST", headers, body: payload, signal: controller.signal });
+      await response.clone().arrayBuffer();
+      return response;
+    } catch (error) {
+      throw controller.signal.aborted && controller.signal.reason instanceof Error ? controller.signal.reason : error;
+    } finally {
+      clearTimeout(timer);
+      options.signal?.removeEventListener("abort", onStop);
+    }
+  }
+  return {
+    useLinkToken(token) {
+      linkToken = token;
+    },
+    async call(op, body, options = {}) {
+      const callId = randomUUID2();
+      const payload = JSON.stringify(body);
+      const started = Date.now();
+      input.log.write({ event: "agent_call", callId, op, turnUuid: options.turnUuid, bytes: Buffer.byteLength(payload, "utf8") });
+      let outcome = {
+        ok: false,
+        error: "no response"
+      };
+      try {
+        let response = await send(op, payload, await input.tokenProvider.getAccessToken(), options);
+        if (response.status === 401) {
+          response = await send(op, payload, await input.tokenProvider.refreshAfterUnauthorized(), options);
+        }
+        const text = await response.text();
+        const parsed = parseJson2(text);
+        if (!response.ok) {
+          const code = typeof parsed?.code === "string" ? parsed.code : void 0;
+          outcome = { ok: false, status: response.status, code };
+          throw new AgentCallError(
+            typeof parsed?.detail === "string" ? parsed.detail : `HTTP ${response.status}`,
+            op,
+            response.status,
+            code
+          );
+        }
+        const offers = Array.isArray(parsed?.offers) ? parsed.offers.length : void 0;
+        outcome = { ok: true, status: response.status, offers };
+        return parsed ?? {};
+      } catch (error) {
+        if (error instanceof AgentCallError) throw error;
+        const timedOut = error instanceof Error && (error.name === "TimeoutError" || error.name === "AbortError");
+        outcome = { ok: false, error: timedOut ? error.name : error instanceof Error ? error.message : String(error) };
+        throw new AgentCallError(timedOut ? `${op} timed out` : `${op} failed: ${outcome.error}`, op);
+      } finally {
+        input.log.write({ event: "agent_call_response", callId, op, ...outcome, ms: Date.now() - started });
+      }
+    }
+  };
+}
+function parseJson2(text) {
+  if (!text) return void 0;
+  try {
+    const value = JSON.parse(text);
+    return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+  } catch {
+    return void 0;
+  }
+}
+
+// src/core/agent/log.ts
+function openAgentLog(paths) {
+  const log = new DaemonLog(paths.log, paths.previousLog);
+  log.enableRotation();
+  return log;
+}
+
+// src/core/agent/paths.ts
 import { homedir as homedir3 } from "os";
+import { join as join7 } from "path";
+function agentPaths(home = homedir3()) {
+  const dir = join7(home, ".ainecto", "agent");
+  return {
+    dir,
+    work: join7(dir, "work"),
+    sessions: join7(dir, "sessions.json"),
+    log: join7(dir, "agent.log"),
+    previousLog: join7(dir, "agent.log.1")
+  };
+}
+
+// src/core/agent/prompt.ts
+function agentPromptText(text, context) {
+  const parts = [];
+  const p = context?.project;
+  if (p && typeof p.uuid === "string") {
+    parts.push(`project \xAB${str(p.name)}\xBB (projectUuid ${p.uuid}${typeof p.workspaceUuid === "string" ? `, workspace \xAB${str(p.workspaceName)}\xBB ${p.workspaceUuid}` : ""})`);
+  }
+  const d = context?.openDocument;
+  if (d && typeof d.uuid === "string") {
+    parts.push(`open document \xAB${str(d.title)}\xBB (documentUuid ${d.uuid}${typeof d.type === "string" ? `, ${d.type}` : ""})`);
+  }
+  if (parts.length === 0) return text;
+  return `[AiNecto context \u2014 "this project" / "this document" mean these] ${parts.join(" \xB7 ")}
+
+${text}`;
+}
+function str(value) {
+  return typeof value === "string" ? value : "";
+}
+
+// src/core/agent/reply.ts
+function replyForOutcome(outcome, limits) {
+  const documentUuids = outcome.kind === "result" ? outcome.documents.slice(0, limits.documentsMax) : [];
+  const failed = (errorCode2, text) => ({ status: "FAILED", errorCode: errorCode2, reply: clip(text, limits.textMaxCharacters), documentUuids });
+  switch (outcome.kind) {
+    case "timeout":
+      return failed("TURN_TIMEOUT", "\uC81C\uD55C \uC2DC\uAC04 \uC548\uC5D0 \uB05D\uB098\uC9C0 \uC54A\uC544 \uBA48\uCDC4\uC5B4\uC694. \uB2E4\uC2DC \uBCF4\uB0B4 \uC8FC\uC138\uC694.");
+    case "exited":
+      return failed("AGENT_EXITED", `Claude Code \uAC00 \uB05D\uB0AC\uC5B4\uC694(code ${outcome.code ?? "-"}${outcome.signal ? `, ${outcome.signal}` : ""}).` + (outcome.stderrTail ? `
+${outcome.stderrTail}` : ""));
+    case "result": {
+      const { result } = outcome;
+      if (result.isError) {
+        return failed("AGENT_ERROR", `Claude Code \uAC00 \uC2E4\uD328\uD588\uC5B4\uC694(${result.subtype ?? "error"}).` + (result.resultText ? `
+${result.resultText}` : ""));
+      }
+      const reply = result.structuredOutput?.reply;
+      const keys = result.structuredOutput && typeof result.structuredOutput === "object" ? Object.keys(result.structuredOutput) : [];
+      if (typeof reply === "string" && reply.trim().length > 0 && keys.length === 1 && codePoints(reply) <= limits.textMaxCharacters) {
+        return { status: "DONE", reply, documentUuids };
+      }
+      const raw = result.structuredOutput !== void 0 ? JSON.stringify(result.structuredOutput) : result.resultText ?? "";
+      return failed("SCHEMA_VIOLATION", `\uB2F5 \uD615\uC2DD\uC774 \uC5B4\uAE0B\uB0AC\uC5B4\uC694.
+${raw}`);
+    }
+  }
+}
+function codePoints(text) {
+  return Array.from(text).length;
+}
+function clip(text, max) {
+  const chars = Array.from(text.trim() || "-");
+  return chars.length <= max ? chars.join("") : `${chars.slice(0, max - 1).join("")}\u2026`;
+}
+
+// src/core/agent/serve.ts
+async function runAgentServe(deps) {
+  const opened = await deps.http.call("open", { hostName: deps.hostName, cliVersion: deps.cliVersion });
+  const linkId = String(opened.linkId);
+  deps.http.useLinkToken(String(opened.linkToken));
+  const limits = serverLimits(opened.limits);
+  deps.print(`Connected to AiNecto as ${deps.hostName}. Requests to \xABMy agent\xBB in AiNecto Chat now run in Claude Code on this machine. Press Ctrl+C to stop.`);
+  const stopController = new AbortController();
+  let stopReason;
+  let exitCode2 = 0;
+  let wakeWorker;
+  let current;
+  const received = /* @__PURE__ */ new Set();
+  const queue = [];
+  const stop = (reason, code, message) => {
+    if (stopReason) return;
+    stopReason = reason;
+    exitCode2 = code;
+    if (message) deps.print(message);
+    stopController.abort();
+    wakeWorker?.();
+    void current?.stop();
+  };
+  const onUserStop = () => stop("signal", 0, "Stopping\u2026");
+  if (deps.signal.aborted) onUserStop();
+  deps.signal.addEventListener("abort", onUserStop, { once: true });
+  const stopOnFatal = (error) => {
+    if (error.code === "LINK_NOT_FOUND") {
+      stop("link_not_found", 1, "This connection ended (the server restarted, or the link was closed). Run `ainecto agent serve` again.");
+    } else if (error.status === 401 || error.status === 403) {
+      stop("auth", 1, `AiNecto refused the CLI sign-in (${error.code ?? error.status}). Run \`ainecto auth login\` and start again.`);
+    }
+  };
+  const pollLoop = (async () => {
+    let delay;
+    while (!stopReason) {
+      try {
+        const res = await deps.http.call("poll", { linkId }, { holdMs: limits.pollHoldSeconds * 1e3, signal: stopController.signal });
+        delay = void 0;
+        if (res.state === "CLOSED") {
+          stop("replaced", 1, "Another PC connected as your agent, so this one stopped.");
+          return;
+        }
+        for (const offer of offersIn(res)) {
+          const duplicate = received.has(offer.turnUuid);
+          deps.log.write({ event: "offer", turnUuid: offer.turnUuid, conversationUuid: offer.conversationUuid, duplicate });
+          if (duplicate) continue;
+          received.add(offer.turnUuid);
+          queue.push(offer);
+          wakeWorker?.();
+        }
+      } catch (error) {
+        if (stopReason) return;
+        if (error instanceof AgentCallError && !error.retryable) {
+          stopOnFatal(error);
+          if (stopReason) return;
+        }
+        delay = nextRetryDelay(delay);
+        await sleep(delay, stopController.signal);
+      }
+    }
+  })();
+  const runTurn = async (offer) => {
+    if (current && (current.conversationUuid !== offer.conversationUuid || !current.alive)) {
+      await current.stop();
+      current = void 0;
+    }
+    if (!current) {
+      const resumeSessionId = deps.sessions.get(offer.conversationUuid);
+      current = new ClaudeAgentProcess(
+        offer.conversationUuid,
+        resumeSessionId !== void 0,
+        deps.claudeArgs({ textMaxCharacters: limits.textMaxCharacters, resumeSessionId }),
+        { cwd: deps.cwd, env: deps.env, spawnImpl: deps.spawnImpl, writeTools: deps.writeTools, log: deps.log }
+      );
+    }
+    const proc = current;
+    const started = Date.now();
+    deps.log.write({ event: "agent_request", turnUuid: offer.turnUuid, conversationUuid: offer.conversationUuid, pid: proc.pid, textLength: offer.text.length });
+    let outcome;
+    let reply;
+    let failure2;
+    try {
+      outcome = await proc.runTurn(agentPromptText(offer.text, offer.context), deps.turnTimeoutMs ?? AGENT_TURN_TIMEOUT_MS);
+      if (outcome.kind === "timeout") {
+        await proc.stop();
+      }
+      if (outcome.kind !== "result") {
+        current = current === proc ? void 0 : current;
+        if (proc.resumed) await deps.sessions.forget(offer.conversationUuid);
+      } else if (proc.sessionId) {
+        await deps.sessions.set(offer.conversationUuid, proc.sessionId);
+      }
+      reply = replyForOutcome(outcome, limits);
+      return reply;
+    } catch (error) {
+      failure2 = error instanceof Error ? error.message : String(error);
+      reply = { status: "FAILED", errorCode: "AGENT_INTERNAL", reply: `The PC agent failed: ${failure2}`.slice(0, limits.textMaxCharacters), documentUuids: [] };
+      return reply;
+    } finally {
+      const result = outcome?.kind === "result" ? outcome.result : void 0;
+      deps.log.write({
+        event: "agent_response",
+        turnUuid: offer.turnUuid,
+        ms: Date.now() - started,
+        outcome: outcome?.kind ?? `error: ${failure2 ?? "unknown"}`,
+        status: reply?.status ?? "FAILED",
+        errorCode: reply?.errorCode,
+        subtype: result?.subtype,
+        sessionId: proc.sessionId,
+        documents: reply?.documentUuids.length ?? 0,
+        numTurns: result?.numTurns,
+        costUsd: result?.costUsd
+      });
+    }
+  };
+  const sendReply = async (offer, reply) => {
+    let delay;
+    for (; ; ) {
+      try {
+        await deps.http.call("reply", {
+          linkId,
+          turnUuid: offer.turnUuid,
+          conversationUuid: offer.conversationUuid,
+          status: reply.status,
+          reply: reply.reply,
+          documentUuids: reply.documentUuids,
+          ...reply.errorCode ? { errorCode: reply.errorCode } : {}
+        }, { turnUuid: offer.turnUuid, signal: stopController.signal });
+        return;
+      } catch (error) {
+        if (stopReason) return;
+        if (error instanceof AgentCallError && !error.retryable) {
+          stopOnFatal(error);
+          return;
+        }
+        delay = nextRetryDelay(delay);
+        await sleep(delay, stopController.signal);
+      }
+    }
+  };
+  const worker = (async () => {
+    while (!stopReason) {
+      const offer = queue.shift();
+      if (!offer) {
+        await new Promise((resolve4) => {
+          wakeWorker = resolve4;
+        });
+        wakeWorker = void 0;
+        continue;
+      }
+      const reply = await runTurn(offer);
+      if (!stopReason) await sendReply(offer, reply);
+    }
+  })();
+  await Promise.allSettled([pollLoop, worker]);
+  deps.signal.removeEventListener("abort", onUserStop);
+  await current?.stop();
+  if (stopReason === "signal") {
+    try {
+      await deps.http.call("close", { linkId });
+    } catch {
+    }
+  }
+  return { exitCode: exitCode2, reason: stopReason ?? "unknown" };
+}
+function serverLimits(value) {
+  const v = value ?? {};
+  const num = (key) => {
+    const n = v[key];
+    if (typeof n !== "number" || !Number.isFinite(n) || n <= 0) {
+      throw new Error(`The server did not send limits.${key}; update the CLI or the server.`);
+    }
+    return n;
+  };
+  return { pollHoldSeconds: num("pollHoldSeconds"), textMaxCharacters: num("textMaxCharacters"), documentsMax: num("documentsMax") };
+}
+function offersIn(res) {
+  if (!Array.isArray(res.offers)) return [];
+  return res.offers.flatMap((o) => {
+    const offer = o;
+    return typeof offer.turnUuid === "string" && typeof offer.conversationUuid === "string" && typeof offer.text === "string" ? [{
+      turnUuid: offer.turnUuid,
+      conversationUuid: offer.conversationUuid,
+      text: offer.text,
+      context: offer.context && typeof offer.context === "object" ? offer.context : void 0
+    }] : [];
+  });
+}
+function sleep(ms, signal) {
+  return new Promise((resolve4) => {
+    if (signal.aborted) {
+      resolve4();
+      return;
+    }
+    const timer = setTimeout(done, ms);
+    signal.addEventListener("abort", done, { once: true });
+    function done() {
+      clearTimeout(timer);
+      signal.removeEventListener("abort", done);
+      resolve4();
+    }
+  });
+}
+
+// src/core/agent/sessions.ts
+import { readFile as readFile9, rename as rename6, writeFile as writeFile6 } from "fs/promises";
+var AgentSessionMap = class {
+  constructor(path) {
+    this.path = path;
+  }
+  path;
+  map = {};
+  async load() {
+    try {
+      const parsed = JSON.parse(await readFile9(this.path, "utf8"));
+      if (parsed.conversations && typeof parsed.conversations === "object") {
+        this.map = parsed.conversations;
+      }
+    } catch (error) {
+      if (isNodeError(error, "ENOENT")) return;
+      this.map = {};
+    }
+  }
+  get(conversationUuid) {
+    return this.map[conversationUuid]?.sessionId;
+  }
+  async set(conversationUuid, sessionId) {
+    this.map[conversationUuid] = { sessionId, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
+    await this.save();
+  }
+  async forget(conversationUuid) {
+    delete this.map[conversationUuid];
+    await this.save();
+  }
+  async save() {
+    const tmp = `${this.path}.tmp`;
+    await writeFile6(tmp, `${JSON.stringify({ version: 1, conversations: this.map }, null, 2)}
+`, { mode: PRIVATE_FILE_MODE });
+    await rename6(tmp, this.path);
+  }
+};
+
+// src/adapters/cli/agentCommand.ts
+var AGENT_HELP_LINES = [
+  "  ainecto agent serve [--env prod|dev]   answer \xABMy agent\xBB requests from AiNecto Chat with Claude Code on this machine (Ctrl+C to stop; log: ~/.ainecto/agent/agent.log)"
+];
+function isAgentCommand(domain, action) {
+  return domain === "agent" && action === "serve";
+}
+async function executeAgentServe(input) {
+  const claude = spawnSync("claude", ["--version"], { encoding: "utf8" });
+  if (claude.error || claude.status !== 0) {
+    throw new Error("Claude Code (`claude`) is not on PATH. Install Claude Code and sign in, then run `ainecto agent serve` again.");
+  }
+  const paths = agentPaths();
+  await ensurePrivateDir(paths.dir);
+  await ensurePrivateDir(paths.work);
+  const log = openAgentLog(paths);
+  const host = hostname();
+  log.write({ event: "serve_start", pid: process.pid, version: CLI_VERSION, endpoint: input.endpoint, host, claude: claude.stdout.trim() });
+  const rpc = new McpRpcClient({ endpoint: input.endpoint, tokenProvider: input.auth, channel: "cli" });
+  const started = Date.now();
+  log.write({ event: "agent_call", callId: `tools-list-${started}`, op: "tools_list", bytes: 0 });
+  let writeTools;
+  try {
+    writeTools = writeToolNames(await rpc.toolsList());
+    log.write({ event: "agent_call_response", callId: `tools-list-${started}`, op: "tools_list", ok: true, ms: Date.now() - started });
+  } catch (error) {
+    log.write({
+      event: "agent_call_response",
+      callId: `tools-list-${started}`,
+      op: "tools_list",
+      ok: false,
+      error: error instanceof Error ? error.message : String(error),
+      ms: Date.now() - started
+    });
+    throw error;
+  }
+  const sessions = new AgentSessionMap(paths.sessions);
+  await sessions.load();
+  const controller = new AbortController();
+  const onSignal = () => controller.abort();
+  process.once("SIGINT", onSignal);
+  process.once("SIGTERM", onSignal);
+  const cliScript = process.argv[1];
+  if (!cliScript) throw new Error("Cannot find the path of this CLI to start the AiNecto bridge for Claude Code.");
+  const mcpConfig = agentMcpConfig(process.execPath, cliScript, input.endpoint);
+  try {
+    const result = await runAgentServe({
+      http: createAgentHttp({ endpoint: input.endpoint, tokenProvider: input.auth, log }),
+      log,
+      sessions,
+      writeTools,
+      claudeArgs: ({ textMaxCharacters, resumeSessionId }) => claudeAgentArgs({ schema: agentReplySchema(textMaxCharacters), mcpConfig, resumeSessionId }),
+      spawnImpl: spawnClaude,
+      cwd: paths.work,
+      env: claudeAgentEnv(process.env),
+      hostName: host,
+      cliVersion: CLI_VERSION,
+      print: (line) => input.io.stderr.write(`${line}
+`),
+      signal: controller.signal
+    });
+    log.write({ event: "serve_stop", pid: process.pid, reason: result.reason });
+    return result.exitCode;
+  } catch (error) {
+    log.write({ event: "serve_stop", pid: process.pid, reason: `error: ${error instanceof Error ? error.message : String(error)}` });
+    throw error;
+  } finally {
+    process.off("SIGINT", onSignal);
+    process.off("SIGTERM", onSignal);
+  }
+}
+
+// src/adapters/cli/ainectoCli.ts
+import { homedir as homedir4 } from "os";
 async function runAinectoCli(argv, io) {
   let parsed = { json: argv.includes("--json"), help: false, version: false, positionals: [] };
   try {
@@ -12650,8 +13377,8 @@ async function runAinectoCli(argv, io) {
         auth,
         client: client2,
         // ★외부 CLI 는 홈 폴더에서 돈다 — 지금 저장소의 local·project 범위 항목이 사용자 범위 판정에 끼지 않게.
-        runner: systemCommandRunner({ cwd: homedir3() }),
-        home: homedir3(),
+        runner: systemCommandRunner({ cwd: homedir4() }),
+        home: homedir4(),
         json: parsed.json,
         io
       });
@@ -12668,9 +13395,9 @@ async function runAinectoCli(argv, io) {
           tokenStore,
           auth,
           client: client2,
-          runner: systemCommandRunner({ cwd: homedir3() }),
+          runner: systemCommandRunner({ cwd: homedir4() }),
           hereRunner: systemCommandRunner({ cwd: process.cwd() }),
-          home: homedir3(),
+          home: homedir4(),
           cwd: process.cwd(),
           envVars: process.env
         },
@@ -12678,6 +13405,9 @@ async function runAinectoCli(argv, io) {
         io
       });
     }
+    if (isAgentCommand(domain, action)) {
+      return await executeAgentServe({ endpoint: resolved.endpoint, auth: connect2().auth, io });
+    }
     if (domain === "auth") {
       return await handleAuth(action, connect2().auth, resolved.endpoint, parsed.json, io);
     }
@@ -12882,6 +13612,9 @@ function helpText() {
     "  ainecto init --agent NAME                             name the agent working in this folder: writes .ainecto/agent.local (do not commit it) and puts the name in .mcp.json, .cursor/mcp.json and .codex/config.toml",
     "  ainecto init --undo",
     "",
+    "Your PC agent (requests from AiNecto Chat, answered by Claude Code on this machine):",
+    ...AGENT_HELP_LINES,
+    "",
     "Terminal sessions on this machine (no tmux or cmux needed; macOS and Linux):",
     ...TERM_HELP_LINES,
     ""