elanous 0.2.4 → 0.2.6

package/src/nexus/api/http-server.ts

@@ -17,6 +17,8 @@
 
 import type { TelegramEvent } from '../../workflow-runtime/triggers/telegram-source.js';
 import { spawnSync } from 'node:child_process';
+import { compareTokenConstTime } from '../../acp/transport/auth.js';
+import { ensureAuthToken } from '../../auth/acp-token.js';
 import type { NexusState } from '../state/state.js';
 import { DEFAULT_NEXUS_HTTP_PORT } from '../default-port.js';
 export { DEFAULT_NEXUS_HTTP_PORT } from '../default-port.js';
@@ -195,6 +197,8 @@ import { handleMcpResourceGet, MCP_RESOURCE_ROUTE_PATH } from './mcp-resource-ro
 // ⛔ 라우트 상수를 «디스패처»가 안 쓰고 문자열로 베끼고 있었다(16차 실측) — 잎에서 읽는다.
 import { APPROVALS_MERGES_PATH, DESIGN_DIRECTION_PATH, DESIGN_PREVIEW_PATH_PREFIX, DESIGN_PREVIEWS_PATH, DESIGN_SYSTEM_PATH, IPA_PATH_PREFIX, MANIFEST_PATH } from './rest-route-paths.js';
 import { handleMergeApprovals } from './merge-approvals.js';
+import { GRAPH_APPROVALS_PATH, handleGraphApprovals } from './graph-approvals.js';
+import { FIELD_SERVER_MAX_BODY_BYTES, FIELD_UPLOADS_PATH, handleFieldUploads } from './field-uploads.js';
 import { handleLiveDetail, LIVE_DETAIL_PATH } from './live-detail.js';
 import { handleLiveShipped, LIVE_SHIPPED_PATH } from './live-shipped.js';
 import { handleMcpWidgetCall, MCP_WIDGET_CALL_ROUTE_PATH, persistWidgetTurnToSessionStore } from './mcp-widget-call-route.js';
@@ -300,6 +304,7 @@ import {
   handleVoiceCost,
   handleVoiceTranscribe,
   checkAuth,
+  bearerCredential,
   registerAuthPeerAddress,
   type MetaApiOpts,
 } from './meta-api.js';
@@ -332,7 +337,10 @@ import { handleTriggersSnapshot } from './triggers.js';
 import { handleWorkflowTemplatesList } from './workflow-templates.js';
 import { handleGraphsGet, handleGraphsMutation } from './graphs-api.js';
 import { handleGraphKindsGet, handleGraphsValidatePost } from './graph-kinds.js';
-import { handlePluginsIndexGet, handlePluginsGet } from './plugins-market.js';
+import { syncInstalledPluginNodes } from '../../graph-kinds/installed-plugin-nodes.js';
+import { elanousStateRoot } from '../../autopilot/state-paths.js';
+import { handlePluginsIndexGet, handlePluginsGet, handlePluginsMarketRefresh, handlePluginsInstall, handlePluginsRemove } from './plugins-market.js';
+import { handlePluginsCredentialsGet, handlePluginsCredentialsPut } from './plugins-credentials-api.js';
 import {
   handleWorkflowsList,
 } from './workflows.js';
@@ -369,7 +377,7 @@ import {
   parseAgentCliSessionPath,
 } from './agent-cli.js';
 import { handleSessionTurnControl, SESSION_TURN_CONTROL_PATH } from '../../session/session-turn-control.js';
-import { authenticatePodCredential, handlePodGrokCredential, POD_CREDENTIAL_GROK_PATH } from './pod-credential-api.js';
+import { authenticatePodCredential, handlePodGrokCredential, handlePodGithubCredential, POD_CREDENTIAL_GROK_PATH, POD_CREDENTIAL_GITHUB_PATH } from './pod-credential-api.js';
 import { handleOutboundReport } from './outbound-report.js';
 import { handleSelfEvent } from './self-event.js';
 /** 매매 «실행»은 애드온이다(대표 09-20 결정 ③ · 별도 상용 저장소 · release/trading-export.yaml) — 공개 코어엔 없다.
@@ -436,6 +444,8 @@ export function probeNexusHttpPort(
 export type NexusWsBridgeInit = Omit<WsBridgeOpts, 'hostname' | 'port'>;
 
 export interface NexusHttpServerOpts {
+  /** Optional installer state root for isolated API consumers and tests. */
+  pluginStateRoot?: string;
   state: NexusState;
   registry: TabRegistry;
   eventBus: NexusEventBus;
@@ -730,6 +740,8 @@ export function startNexusHttpServer(opts: NexusHttpServerOpts): NexusHttpServer
         port,
         hostname,
         idleTimeout: 255,
+        // Bun 기본 128 MB 로는 현장 업로드(파일 200 MB · 요청 500 MB · JSON base64)가 못 들어온다.
+        maxRequestBodySize: FIELD_SERVER_MAX_BODY_BYTES,
         fetch: async (req: Request, srv: unknown) =>
           (await routeRequest(req, opts, srv as BunServerLike, bridge, devProxyRef, { hostname, port })) ??
           new Response(null, { status: 101 }),
@@ -822,19 +834,27 @@ export async function routeRequest(
   // Per-route checkAuth calls below stay in place.
   // OPTIONS is a CORS preflight and cannot carry Authorization; existing
   // handlers answer it themselves, so the gate does not swallow it.
+  // A runtime-less tab mutation still needs authentication before the
+  // dispatcher can return its 503. Do not enable this fallback for other paths.
+  const runtimeLessTabMutation = !opts.metaApi && method !== 'GET' && method !== 'OPTIONS'
+    && (pathname === '/v1/nexus/tabs' || pathname.startsWith('/v1/nexus/tabs/'));
   if (
     method !== 'OPTIONS'
     && pathname.startsWith('/v1/')
     && !isPublicRoute(method, pathname, { setupMode: false })
   ) {
-    if (!opts.metaApi || !checkAuth(req, opts.metaApi)) {
+    const fallbackToken = runtimeLessTabMutation ? ensureAuthToken().token : undefined;
+    const offered = req.headers.get('authorization');
+    const fallbackAuthorized = fallbackToken !== undefined && offered?.startsWith('Bearer ') === true
+      && compareTokenConstTime(offered.slice('Bearer '.length).trim(), fallbackToken);
+    if (!(opts.metaApi ? checkAuth(req, opts.metaApi) : fallbackAuthorized)) {
       const name = method === 'POST' && pathname === '/v1/tasks' && opts.metaApi
         ? matchIngestAuthorization(req)?.name
         : undefined;
       if (name === undefined) {
         debug.log('nexus.auth', 'default-deny', { method, pathname });
         // MCP 클라이언트(Claude Code)에게는 «할 일»을 말한다 — 안 그러면 OAuth 로 가서 /register 405 를 만난다.
-        if (pathname === '/v1/mcp') return mcpUnauthorizedResponse();
+        if (pathname === '/v1/mcp') return mcpUnauthorizedResponse(new URL(req.url).origin);
         return jsonResponse({ error: 'unauthorized' }, 401);
       }
       debug.log('nexus.auth', 'ingest-token', { name, pathname });
@@ -843,7 +863,7 @@ export async function routeRequest(
   // OAuth 동적 클라이언트 등록(RFC 7591) — Elanous 는 OAuth 를 쓰지 않는다. 405 대신 «이렇게 등록하라»를 돌려준다.
   if (method === 'POST' && pathname === '/register') {
     debug.log('nexus.auth', 'oauth-register-rejected', { pathname });
-    return oauthRegistrationRejected();
+    return oauthRegistrationRejected(new URL(req.url).origin);
   }
 
   // FU2 (2026-05-12) — root-level browser conveniences. The PWA serves
@@ -899,6 +919,18 @@ export async function routeRequest(
     });
   }
 
+  if (pathname === GRAPH_APPROVALS_PATH || pathname.startsWith(`${GRAPH_APPROVALS_PATH}/`)) {
+    return handleGraphApprovals(req, {
+      authorize: (request) => !!opts.metaApi && checkAuth(request, opts.metaApi),
+      authReason: (request) => (opts.metaApi ? bearerCredential(request, opts.metaApi) : undefined),
+    });
+  }
+  // 현장 업로드(owner 전용) — GET 목록 · POST 저장. 저장 규칙 정본 = src/field/field-media.ts.
+  if (pathname === FIELD_UPLOADS_PATH && (method === 'GET' || method === 'POST')) {
+    return handleFieldUploads(req, {
+      authorize: (request) => !!opts.metaApi && checkAuth(request, opts.metaApi),
+    });
+  }
   if (pathname === APPROVALS_MERGES_PATH || pathname.startsWith(`${APPROVALS_MERGES_PATH}/`)) {
     return handleMergeApprovals(req, {
       authorize: (request) => !!opts.metaApi && checkAuth(request, opts.metaApi),
@@ -1189,6 +1221,25 @@ export async function routeRequest(
   // Templates POST handled here too (PR κ).
   // Config / secrets PUT/POST/DELETE here too (PR μ).
   if (method !== 'GET') {
+    if (method === 'POST' && pathname === '/v1/plugins/install') {
+      if (!opts.metaApi) return jsonResponse({ error: 'unauthorized' }, 401);
+      return handlePluginsInstall(req, opts.metaApi, opts.pluginStateRoot);
+    }
+    const marketRefresh = /^\/v1\/plugins\/markets\/([^/]+)\/refresh$/.exec(pathname);
+    if (method === 'POST' && marketRefresh) {
+      if (!opts.metaApi) return jsonResponse({ error: 'unauthorized' }, 401);
+      return handlePluginsMarketRefresh(req, marketRefresh[1]!, opts.metaApi, { root: opts.pluginStateRoot });
+    }
+    const pluginCredentials = /^\/v1\/plugins\/([^/]+)\/credentials$/.exec(pathname);
+    if (method === 'PUT' && pluginCredentials) {
+      if (!opts.metaApi) return jsonResponse({ error: 'unauthorized' }, 401);
+      return handlePluginsCredentialsPut(req, pluginCredentials[1]!, opts.metaApi, opts.pluginStateRoot, opts.reloadMcpClients);
+    }
+    const pluginRemove = /^\/v1\/plugins\/([^/]+)$/.exec(pathname);
+    if (method === 'DELETE' && pluginRemove) {
+      if (!opts.metaApi) return jsonResponse({ error: 'unauthorized' }, 401);
+      return handlePluginsRemove(req, pluginRemove[1]!, opts.metaApi, opts.pluginStateRoot);
+    }
     if ((method === 'PUT' || method === 'POST') && pathname.startsWith('/v1/graphs/')) {
       if (!opts.metaApi) return jsonResponse({ error: 'meta-api-not-wired' }, 503);
       if (!checkAuth(req, opts.metaApi)) return jsonResponse({ error: 'unauthorized' }, 401);
@@ -1215,6 +1266,11 @@ export async function routeRequest(
       if (!gate.ok) return gate.response;
       return handlePodGrokCredential(req);
     }
+    if (pathname === POD_CREDENTIAL_GITHUB_PATH && method === 'POST') {
+      const gate = await authenticatePodCredential(req, {}, 'gh-credential');
+      if (!gate.ok) return gate.response;
+      return handlePodGithubCredential(req);
+    }
     if (pathname === '/v1/harness/ask' && method === 'POST') {
       if (!opts.metaApi) return jsonResponse({ error: 'meta-api-runtime-not-wired' }, 503);
       if (!checkAuth(req, opts.metaApi)) return jsonResponse({ error: 'unauthorized' }, 401);
@@ -2431,12 +2487,19 @@ export async function routeRequest(
   // surface (`/v1/workflows` · `~/.elanous/workflows-runs/`) covers the same
   // user need.
 
+  const pluginCredentialsGet = /^\/v1\/plugins\/([^/]+)\/credentials$/.exec(pathname);
+  if (method === 'GET' && pluginCredentialsGet) {
+    if (!opts.metaApi) return jsonResponse({ error: 'unauthorized' }, 401);
+    return handlePluginsCredentialsGet(req, pluginCredentialsGet[1]!, opts.metaApi, opts.pluginStateRoot);
+  }
   if (method === 'GET' && (pathname === '/v1/plugins/index' || pathname === '/v1/plugins')) {
     if (!opts.metaApi || !checkAuth(req, opts.metaApi)) return jsonResponse({ error: 'unauthorized' }, 401);
-    return pathname === '/v1/plugins/index' ? handlePluginsIndexGet(req, opts.metaApi) : handlePluginsGet(req, opts.metaApi);
+    return pathname === '/v1/plugins/index' ? handlePluginsIndexGet(req, opts.metaApi, opts.pluginStateRoot) : handlePluginsGet(req, opts.metaApi, opts.pluginStateRoot);
   }
   if (method === 'GET' && pathname === '/v1/graph/kinds') {
     if (!opts.metaApi || !checkAuth(req, opts.metaApi)) return jsonResponse({ error: 'unauthorized' }, 401);
+    try { syncInstalledPluginNodes(opts.pluginStateRoot ?? elanousStateRoot()); }
+    catch (error) { debug.log('graph.kinds', 'installed-sync-failed', { reason: String(error) }); }
     return handleGraphKindsGet(req, opts.metaApi);
   }
   // F-M1 read + P-F1 raw YAML. Writes live in the mutation block and never touch core graphs/.

package/src/nexus/api/log-fabric.ts

@@ -301,6 +301,15 @@ export function activeStoreNames(deps: LogFabricDeps, nowMs = Date.now()): strin
   return names;
 }
 
+/** 등록된 로그 저장소 수(이 인스턴스 ⊕ logs.db 가 있는 우주) — `@active` 가 연 수의 «분모». 못 세면 `null`(0 으로 접지 않는다). */
+export function registeredLogStoreCount(deps: Pick<LogFabricDeps, 'instances'> = {}): number | null {
+  try {
+    const names = new Set((deps.instances ?? readLogInstances)().filter((view) => view.dbExists).map((view) => view.name));
+    names.add(resolveLogInstanceName());
+    return names.size;
+  } catch { return null; }
+}
+
 export function handleLogsQuery(req: Request, opts: MetaApiOpts, deps: LogFabricDeps = {}): Response {
   if (!checkAuth(req, opts)) return jsonResponse({ error: 'unauthorized' }, 401);
   const url = new URL(req.url);
@@ -374,7 +383,7 @@ export function handleLogsQuery(req: Request, opts: MetaApiOpts, deps: LogFabric
     ts: new Date().toISOString(),
     ...(failedStores.length ? { failedStores } : {}),
     ...(selection.storeLimitReached ? { storeLimitReached: true } : {}),
-    ...(activeStores ? { stores: activeStores } : {}),
+    ...(activeStores ? { stores: activeStores, registeredStores: registeredLogStoreCount(deps) } : {}),
   }, 200);
 }
 

package/src/nexus/api/mcp-oauth-hint.ts

@@ -3,15 +3,16 @@
 // 사람은 무엇을 해야 할지 몰랐다(🅢 09-28 · 대표 승인 수리). Elanous 는 OAuth 를 쓰지 않는다 — 고정 Bearer 토큰이다.
 // ⇒ 두 자리에서 «할 일»을 말한다: ① 401 의 `WWW-Authenticate` ② `/register` 의 RFC 7591 오류 본문(Claude Code 가 그대로 보여 준다).
 
-/** 토큰 «값»은 절대 싣지 않는다 — 파일 경로와 명령만. */
-export const MCP_AUTH_HINT =
-  'Elanous 는 OAuth 를 쓰지 않는다(고정 Bearer 토큰). 권장: stdio 로 등록 — `claude mcp add elanous -- elanous mcp serve`. '
-  + 'HTTP 가 필요하면 ~/.elanous/acp-token 의 값을 Authorization 헤더로: '
-  + '`claude mcp add --transport http elanous http://127.0.0.1:31415/v1/mcp --header "Authorization: Bearer <acp-token>"`';
+/** 토큰 «값»은 절대 싣지 않는다 — 파일 경로와 명령만. 주소는 포트를 짐작하지 않고 «요청이 닿은 origin»을 쓴다(대표 09-28 통합관제). */
+export function mcpAuthHint(origin: string): string {
+  return 'Elanous 는 OAuth 를 쓰지 않는다(고정 Bearer 토큰). 권장: stdio 로 등록 — `claude mcp add elanous -- elanous mcp serve`. '
+    + 'HTTP 가 필요하면 ~/.elanous/acp-token 의 값을 Authorization 헤더로: '
+    + `\`claude mcp add --transport http elanous ${origin}/v1/mcp --header "Authorization: Bearer <acp-token>"\``;
+}
 
 /** `/v1/mcp` 401 — 무엇을 해야 하는지 헤더로도 말한다(WWW-Authenticate 의 error_description 은 ASCII 만). */
-export function mcpUnauthorizedResponse(): Response {
-  return new Response(JSON.stringify({ error: 'unauthorized', hint: MCP_AUTH_HINT }), {
+export function mcpUnauthorizedResponse(origin: string): Response {
+  return new Response(JSON.stringify({ error: 'unauthorized', hint: mcpAuthHint(origin) }), {
     status: 401,
     headers: {
       'content-type': 'application/json; charset=utf-8',
@@ -22,8 +23,8 @@ export function mcpUnauthorizedResponse(): Response {
 }
 
 /** OAuth 동적 클라이언트 등록 거절 — RFC 7591 §3.2.2 오류 형식(Claude Code 가 본문을 사람에게 보여 준다). */
-export function oauthRegistrationRejected(): Response {
-  return new Response(JSON.stringify({ error: 'invalid_client_metadata', error_description: MCP_AUTH_HINT }), {
+export function oauthRegistrationRejected(origin: string): Response {
+  return new Response(JSON.stringify({ error: 'invalid_client_metadata', error_description: mcpAuthHint(origin) }), {
     status: 400,
     headers: { 'content-type': 'application/json; charset=utf-8', 'access-control-allow-origin': '*' },
   });

package/src/nexus/api/merge-approvals.ts

@@ -98,13 +98,14 @@ function asItem(pr: RawPr) {
 }
 
 // A page load fires the list twice (the daemon client settles) and polls cards — identical reads share one gh call.
+// Failures are shared too: during a GitHub rate-limit window a retry per request only deepens the limit (GIT-S83).
 const readCache = new Map<string, { at: number; value: Promise<GhResult> }>();
 export function clearApprovalsReadCache(): void { readCache.clear(); }
 function cachedRead(args: string[], ttlMs: number, now: number, call: () => Promise<GhResult>): Promise<GhResult> {
   const key = args.join('\u0000');
   const hit = readCache.get(key);
   if (hit && now - hit.at < ttlMs) return hit.value;
-  const value = call().then((result) => { if (!result.ok) readCache.delete(key); return result; });
+  const value = call();
   readCache.set(key, { at: now, value });
   return value;
 }

package/src/nexus/api/meta-api.ts

@@ -254,6 +254,10 @@ function decideAuth(req: Request, opts: MetaApiOpts): { ok: boolean; reason: Aut
   if (isSameOriginRequest(req, peerAddress)) return { ok: true, reason: 'same-origin' };
   const peerRejected = req.headers.get('sec-fetch-site') === 'same-origin'
     && !isTrustedSameOriginPeer(peerAddress);
+  return decideBearer(req, opts, peerRejected);
+}
+
+function decideBearer(req: Request, opts: MetaApiOpts, peerRejected = false): { ok: boolean; reason: AuthReason } {
   const token = opts.bearerToken;
   if (!token) return { ok: false, reason: peerRejected ? 'untrusted-same-origin-peer' : 'no-bearer-configured' };
   const auth = req.headers.get('authorization') ?? '';
@@ -273,6 +277,16 @@ function decideAuth(req: Request, opts: MetaApiOpts): { ok: boolean; reason: Aut
     : { ok: false, reason: 'bearer-mismatch' };
 }
 
+/** Bearer-only credential check that ignores the same-origin shortcut. `checkAuth` returns
+ * `same-origin` before it ever looks at the Authorization header, so a paired PWA that sends its
+ * token is still reported as same-origin — write paths that must not trust same-origin alone
+ * (graph approvals) ask this instead. Returns the credential kind, or undefined if none matched. */
+export function bearerCredential(req: Request, opts: MetaApiOpts): 'noauth' | 'bearer-match' | 'temp-token' | undefined {
+  if (opts.noAuth) return 'noauth';
+  const decision = decideBearer(req, opts);
+  return decision.ok && (decision.reason === 'bearer-match' || decision.reason === 'temp-token') ? decision.reason : undefined;
+}
+
 // Exported so sibling NEXUS API modules (e.g. T5.G `tasks-scheduler.ts`)
 // can reuse the exact same gate — same-origin + constant-time bearer
 // check — without duplicating security-sensitive code.

package/src/nexus/api/plugins-credentials-api.ts

@@ -0,0 +1,47 @@
+import { debug } from '../../debug/log.js';
+import { credentialStatus, setPluginCredentials } from '../../plugins/install/plugin-credentials.js';
+import { checkAuth, type MetaApiOpts } from './meta-api.js';
+import { jsonResponse } from './json-response.js';
+
+const NAME = /^[a-z0-9][a-z0-9-]{1,39}$/;
+
+function failure(error: unknown): Response {
+  if (error instanceof Error && error.message.startsWith('plugin not installed:')) return jsonResponse({ error: 'not_found' }, 404);
+  if (error instanceof Error && (error.message === 'invalid plugin name' || error.message === 'invalid plugin credential field'
+    || error.message === 'invalid plugin credential fields')) {
+    return jsonResponse({ error: 'bad_request' }, 400);
+  }
+  return jsonResponse({ error: 'credential_error' }, 500);
+}
+
+export function handlePluginsCredentialsGet(req: Request, name: string, opts: MetaApiOpts, root?: string): Response {
+  if (!checkAuth(req, opts)) return jsonResponse({ error: 'unauthorized' }, 401);
+  if (!NAME.test(name)) return jsonResponse({ error: 'bad_request' }, 400);
+  try { return jsonResponse(credentialStatus(name, root), 200); }
+  catch (error) { return failure(error); }
+}
+
+/** `reload` re-spawns the daemon's MCP clients so a running plugin server picks up the new values
+ *  (the spawn reads `pluginEnv` fresh). A failed reload never fails the write — the reply says so. */
+export async function handlePluginsCredentialsPut(req: Request, name: string, opts: MetaApiOpts, root?: string, reload?: () => Promise<unknown>): Promise<Response> {
+  if (!checkAuth(req, opts)) return jsonResponse({ error: 'unauthorized' }, 401);
+  if (!NAME.test(name)) return jsonResponse({ error: 'bad_request' }, 400);
+  let body: unknown;
+  try { body = await req.json(); }
+  catch { return jsonResponse({ error: 'bad_request' }, 400); }
+  const fields = body && typeof body === 'object' && !Array.isArray(body) ? (body as Record<string, unknown>).fields : undefined;
+  if (!fields || typeof fields !== 'object' || Array.isArray(fields)
+    || Object.values(fields).some(value => typeof value !== 'string' && value !== null)) {
+    return jsonResponse({ error: 'bad_request' }, 400);
+  }
+  try {
+    const result = setPluginCredentials(name, fields as Record<string, string | null>, root);
+    debug.log('plugin.credentials', 'set', { plugin: name, fields: Object.keys(fields), count: Object.keys(fields).length });
+    let reloaded = false;
+    if (reload) {
+      try { await reload(); reloaded = true; }
+      catch { debug.log('plugin.credentials', 'reload-failed', { plugin: name }, { level: 'warn' }); }
+    }
+    return jsonResponse({ ...result, reloaded }, 200);
+  } catch (error) { return failure(error); }
+}

package/src/nexus/api/plugins-market.ts

@@ -4,7 +4,8 @@ import { elanousStateRoot } from '../../autopilot/state-paths.js';
 import { debug } from '../../debug/log.js';
 import { OFFICIAL_INDEX_KEYS } from '../../market/official-keys.js';
 import { verifyIndex, type MarketplaceIndex } from '../../market/signed-index.js';
-import { listInstalledPlugins } from '../../plugins/install/plugin-install.js';
+import { installPlugin, listInstalledPlugins, removePlugin, type InstallEvent } from '../../plugins/install/plugin-install.js';
+import { updateMarket, type MarketFetchOptions } from '../../plugins/install/market-fetch.js';
 import { userConfigPath } from '../../user-config.js';
 import { jsonResponse } from './json-response.js';
 import { checkAuth, type MetaApiOpts } from './meta-api.js';
@@ -66,7 +67,7 @@ export function readMarketIndex(root = elanousStateRoot(), trustedKeys: Readonly
     const dir = join(base, entry.name);
     const indexPath = [join(dir, 'marketplace.json'), join(dir, '.agents', 'plugins', 'marketplace.json')].find(existsSync);
     if (!indexPath) {
-      markets.push({ name: entry.name, signature: 'malformed', detail: 'marketplace.json: not found', plugins: [] });
+      markets.push({ name: entry.name, signature: 'malformed', detail: '마켓 인덱스를 찾지 못했습니다.', plugins: [] });
       continue;
     }
     let signature: MarketSignature = 'missing';
@@ -93,7 +94,7 @@ export function readMarketIndex(root = elanousStateRoot(), trustedKeys: Readonly
       signature = 'malformed';
       detail = 'marketplace.json: invalid market index';
     }
-    markets.push({ name: entry.name, signature, ...(detail ? { detail } : {}), plugins });
+    markets.push({ name: entry.name, signature, ...(detail ? { detail: '마켓 인덱스를 확인하지 못했습니다.' } : {}), plugins });
   }
   markets.sort((a, b) => a.name.localeCompare(b.name));
   debug.log('nexus.plugins-market', 'index', { markets: markets.length, ok: markets.filter(m => m.signature === 'ok').length, notOk: markets.filter(m => m.signature !== 'ok').length });
@@ -123,3 +124,86 @@ export function handlePluginsGet(req: Request, opts: MetaApiOpts, root?: string)
   if (!checkAuth(req, opts)) return jsonResponse({ error: 'unauthorized' }, 401);
   return jsonResponse(listInstalledPlugins(root));
 }
+
+const MARKET_NAME = /^[a-z0-9][a-z0-9-]{1,39}$/;
+const MARKET_SPEC = /^[a-z0-9][a-z0-9-]{1,39}@[a-z0-9][a-z0-9-]{1,39}$/;
+
+/** 실패 원인 한 줄 — 사용자가 «왜» 를 볼 수 있게(2026-09-29 실물: «설치 중 오류가 발생했습니다» 만 보여 아티팩트 누락을 못 봤다). 홈 경로는 `~` 로 · 200자 · 한 줄. */
+export function safeDetail(error: unknown): string | undefined {
+  const message = error instanceof Error ? error.message : typeof error === 'string' ? error : undefined;
+  if (!message) return undefined;
+  return message.replace(/\/(?:Users|home)\/[^/\s]+/g, '~').replace(/\s+/g, ' ').trim().slice(0, 200) || undefined;
+}
+
+function safeReason(error: unknown): string {
+  const reason = error && typeof error === 'object' && 'reason' in error ? error.reason : undefined;
+  return typeof reason === 'string' && ['signature', 'scan', 'consent-denied', 'credentials', 'conflict', 'io'].includes(reason)
+    ? reason : 'io';
+}
+
+export async function handlePluginsMarketRefresh(req: Request, name: string, opts: MetaApiOpts, fetchOptions: MarketFetchOptions = {}): Promise<Response> {
+  if (!checkAuth(req, opts)) return jsonResponse({ error: 'unauthorized' }, 401);
+  if (!MARKET_NAME.test(name)) return jsonResponse({ ok: false, reason: 'invalid-market' }, 400);
+  try {
+    const result = await updateMarket(name, fetchOptions);
+    const plugins = projectPlugins(result.index, name);
+    debug.log('nexus.plugins-market', 'refresh', { name, ok: true, count: plugins.length });
+    return jsonResponse({ ok: true, plugins });
+  } catch (error) {
+    const reason = safeReason(error);
+    debug.log('nexus.plugins-market', 'refresh', { name, ok: false, reason });
+    return jsonResponse({ ok: false, reason });
+  }
+}
+
+export async function handlePluginsInstall(req: Request, opts: MetaApiOpts, root?: string, configPath?: string): Promise<Response> {
+  if (!checkAuth(req, opts)) return jsonResponse({ error: 'unauthorized' }, 401);
+  let body: unknown;
+  try { body = await req.json(); } catch { return jsonResponse({ error: 'bad_request' }, 400); }
+  const input = body as { spec?: unknown; acceptedCapabilities?: unknown } | null;
+  if (!input || typeof input.spec !== 'string' || !MARKET_SPEC.test(input.spec) ||
+    !Array.isArray(input.acceptedCapabilities) || !input.acceptedCapabilities.every(cap => typeof cap === 'string')) {
+    return jsonResponse({ error: 'bad_request' }, 400);
+  }
+  const spec = input.spec;
+  const accepted = new Set(input.acceptedCapabilities as string[]);
+  const trustedKeys = configuredTrustedKeys(configPath);
+  const stream = new ReadableStream<Uint8Array>({
+    async start(controller) {
+      const encoder = new TextEncoder();
+      const send = (value: Record<string, unknown>) => controller.enqueue(encoder.encode(`${JSON.stringify(value)}\n`));
+      const onEvent = (event: InstallEvent) => {
+        if (event.event === 'consent') send({ event: 'consent', capabilities: event.capabilities, required: event.required });
+        else if (event.event === 'credentials') send({ event: 'credentials', required: event.connectors.some(c => c.fields.length > 0) });
+        else send({ event: event.event });
+      };
+      try {
+        await installPlugin(spec, {
+          ...(root ? { root } : {}), trustedKeys: [...OFFICIAL_INDEX_KEYS, ...trustedKeys],
+          onEvent, consent: capabilities => capabilities.every(cap => accepted.has(cap)),
+        });
+        debug.log('nexus.plugins-market', 'install', { spec, ok: true });
+      } catch (error) {
+        const reason = safeReason(error);
+        const detail = safeDetail(error);
+        debug.log('nexus.plugins-market', 'install', { spec, ok: false, reason, ...(detail ? { detail } : {}) });
+        send({ event: 'failed', reason, ...(detail ? { detail } : {}) });
+      } finally { controller.close(); }
+    },
+  });
+  return new Response(stream, { headers: { 'content-type': 'application/x-ndjson; charset=utf-8', 'cache-control': 'no-store' } });
+}
+
+export function handlePluginsRemove(req: Request, name: string, opts: MetaApiOpts, root?: string): Response {
+  if (!checkAuth(req, opts)) return jsonResponse({ error: 'unauthorized' }, 401);
+  if (!MARKET_NAME.test(name)) return jsonResponse({ error: 'bad_request' }, 400);
+  try {
+    const removed = removePlugin(name, root);
+    debug.log('nexus.plugins-market', 'remove', { name, removed });
+    return jsonResponse({ removed });
+  } catch (error) {
+    const reason = safeReason(error);
+    debug.log('nexus.plugins-market', 'remove', { name, reason });
+    return jsonResponse({ error: reason }, 500);
+  }
+}

package/src/nexus/api/pod-credential-api.ts

@@ -4,10 +4,14 @@
  *  응답 키는 `key`·`expires_at` 둘뿐. refresh·계정 id·파일 경로는 응답·로그·에러에 싣지 않는다.
  */
 import { debug } from '../../debug/log.js';
-import { verifyGroundingToken, type GroundingTokenDeps } from '../../grounding/token.js';
+import { githubInstallationCredential } from '../../auth/github-app-token.js';
+import { verifyGroundingToken, type GroundingTokenDeps, type GroundingTokenScope } from '../../grounding/token.js';
 import { isGrokSubscriptionExpiring, readGrokSubscriptionAccess, refreshGrokSubscriptionToken } from '../../grok/credential.js';
 
 export const POD_CREDENTIAL_GROK_PATH = '/v1/pod/credential/grok';
+export const POD_CREDENTIAL_GITHUB_PATH = '/v1/pod/credential/github';
+export const POD_GITHUB_CREDENTIAL_TOKEN_ENV = 'ELANOUS_POD_GITHUB_CREDENTIAL_TOKEN';
+export const POD_GITHUB_CREDENTIAL_URL_ENV = 'ELANOUS_POD_GITHUB_CREDENTIAL_URL';
 /** 만료까지 이 안이면 기존 호스트 갱신(`refreshGrokSubscriptionToken`)을 한 번 부른다. */
 export const POD_CREDENTIAL_HOST_REFRESH_WINDOW_MS = 10 * 60 * 1000;
 /** runId 당 분당 1회. */
@@ -27,34 +31,45 @@ export interface PodCredentialDeps {
   readonly loadAccess?: (home: string | undefined, env: NodeJS.ProcessEnv) => { key: string; expiresAt: string } | null;
 }
 
+export interface PodGithubCredentialDeps {
+  readonly token?: GroundingTokenDeps;
+  readonly now?: () => number;
+  readonly mintInstallation?: (repository: string) => { token: string; expires_at: string } | null;
+  readonly installationRepositories?: (token: string) => Promise<readonly string[] | null>;
+}
+
 interface HitWindow {
   readonly stamps: number[];
 }
 
 const hitsByRun = new Map<string, HitWindow>();
 const globalHits: number[] = [];
+const githubHitsByRun = new Map<string, HitWindow>();
+const githubGlobalHits: number[] = [];
 
 export function resetPodCredentialRateForTesting(): void {
   hitsByRun.clear();
   globalHits.length = 0;
+  githubHitsByRun.clear();
+  githubGlobalHits.length = 0;
 }
 
 function prune(stamps: number[], now: number): number[] {
   return stamps.filter((t) => now - t < 60_000);
 }
 
-function takeRate(runId: string, now: number): boolean {
-  const prev = prune(hitsByRun.get(runId)?.stamps ?? [], now);
-  const global = prune(globalHits, now);
-  globalHits.length = 0;
-  globalHits.push(...global);
-  if (prev.length >= POD_CREDENTIAL_PER_RUN_PER_MIN || globalHits.length >= POD_CREDENTIAL_GLOBAL_PER_MIN) {
-    hitsByRun.set(runId, { stamps: prev });
+function takeRate(runId: string, now: number, byRun = hitsByRun, all = globalHits): boolean {
+  const prev = prune(byRun.get(runId)?.stamps ?? [], now);
+  const global = prune(all, now);
+  all.length = 0;
+  all.push(...global);
+  if (prev.length >= POD_CREDENTIAL_PER_RUN_PER_MIN || all.length >= POD_CREDENTIAL_GLOBAL_PER_MIN) {
+    byRun.set(runId, { stamps: prev });
     return false;
   }
   prev.push(now);
-  globalHits.push(now);
-  hitsByRun.set(runId, { stamps: prev });
+  all.push(now);
+  byRun.set(runId, { stamps: prev });
   return true;
 }
 
@@ -109,25 +124,64 @@ export async function handlePodGrokCredential(req: Request, deps: PodCredentialD
   return Response.json({ key: loaded.key, expires_at: expiresAt });
 }
 
+export async function installationRepositories(token: string): Promise<readonly string[] | null> {
+  const response = await fetch('https://api.github.com/installation/repositories?per_page=100', {
+    headers: { authorization: `Bearer ${token}`, accept: 'application/vnd.github+json', 'x-github-api-version': '2022-11-28' },
+    signal: AbortSignal.timeout(10_000),
+  });
+  if (!response.ok) return null;
+  const data: unknown = await response.json();
+  if (!data || typeof data !== 'object' || Array.isArray(data) || !Array.isArray((data as { repositories?: unknown }).repositories)) return null;
+  const body = data as { total_count?: unknown; repositories: unknown[] };
+  if (body.repositories.length !== 1 || body.total_count !== 1) return null;
+  const name = body.repositories[0] && typeof body.repositories[0] === 'object' && !Array.isArray(body.repositories[0]) ? (body.repositories[0] as { full_name?: unknown }).full_name : undefined;
+  return typeof name === 'string' ? [name] : null;
+}
+
+/** No repository is accepted from the request body: the host signed its owner/name into the run token. */
+export async function handlePodGithubCredential(req: Request, deps: PodGithubCredentialDeps = {}): Promise<Response> {
+  const gate = await authenticatePodCredential(req, deps, 'gh-credential');
+  if (!gate.ok) return gate.response;
+  if (!gate.repository || !/^[a-zA-Z0-9_.-]+\/[a-zA-Z0-9_.-]+$/.test(gate.repository)) return Response.json({ error: 'unauthorized' }, { status: 401 });
+  if (!takeRate(gate.runId, (deps.now ?? Date.now)(), githubHitsByRun, githubGlobalHits)) return reasonResponse(429, 'rate');
+
+  let issued: { token: string; expires_at: string } | null;
+  try {
+    issued = (deps.mintInstallation ?? ((repository) => githubInstallationCredential({ scope: { repository: repository.split('/')[1]! } })))(gate.repository);
+  } catch {
+    return reasonResponse(503, 'unavailable');
+  }
+  if (!issued?.token || typeof issued.expires_at !== 'string' || !Number.isFinite(Date.parse(issued.expires_at)) || Date.parse(issued.expires_at) <= (deps.now ?? Date.now)()) return reasonResponse(503, 'unavailable');
+  try {
+    const available = await (deps.installationRepositories ?? installationRepositories)(issued.token);
+    if (available?.length !== 1 || available[0]?.toLowerCase() !== gate.repository.toLowerCase()) return reasonResponse(503, 'unavailable');
+  } catch {
+    return reasonResponse(503, 'unavailable');
+  }
+  debug.log('pod.credential', 'github-issued', { runId: gate.runId, job: gate.job, expiresAt: issued.expires_at });
+  return Response.json({ token: issued.token, expires_at: issued.expires_at });
+}
+
 /**
  * 쓰기 관문. 본문을 읽지 않는다. 토큰이 없거나 서명이 깨지면 401,
  * scope·만료·회수는 403 과 사유만.
  */
 export async function authenticatePodCredential(
   req: Request,
-  deps: PodCredentialDeps = {},
+  deps: Pick<PodCredentialDeps, 'token'> = {},
+  expectedScope: GroundingTokenScope = 'llm-credential',
 ): Promise<
-  | { readonly ok: true; readonly runId: string; readonly job: string; readonly exp: number }
+  | { readonly ok: true; readonly runId: string; readonly job: string; readonly repository?: string; readonly exp: number }
   | { readonly ok: false; readonly response: Response }
 > {
   const token = bearerOf(req);
   if (!token) return { ok: false, response: Response.json({ error: 'unauthorized' }, { status: 401 }) };
-  const verified = await verifyGroundingToken(token, { ...(deps.token ?? {}), expectedScope: 'llm-credential' });
+  const verified = await verifyGroundingToken(token, { ...(deps.token ?? {}), expectedScope });
   if (!verified.ok) {
     if (verified.reason === 'expired' || verified.reason === 'revoked' || verified.reason === 'scope') {
       return { ok: false, response: reasonResponse(403, verified.reason) };
     }
     return { ok: false, response: Response.json({ error: 'unauthorized' }, { status: 401 }) };
   }
-  return { ok: true, runId: verified.runId, job: verified.job, exp: verified.exp };
+  return { ok: true, runId: verified.runId, job: verified.job, ...(verified.repository ? { repository: verified.repository } : {}), exp: verified.exp };
 }

package/src/nexus/api/public-routes.ts

@@ -49,6 +49,13 @@ export const PUBLIC_ROUTES: Array<PublicRoute> = [
     selfVerified: true,
     why: 'Pod grok access relay (#20789); Pods hold no nexus bearer — pod-credential-api.ts verifies its own llm-credential token (verifyGroundingToken expectedScope) before reading the body',
   },
+  {
+    method: 'POST',
+    match: 'exact',
+    path: '/v1/pod/credential/github',
+    selfVerified: true,
+    why: 'Pod GitHub App credential relay verifies its own run-scoped gh-credential token before minting a repository-scoped installation token',
+  },
   {
     method: 'GET',
     match: 'prefix',