axmap-cli 1.4.0 → 1.6.0

package/src/session-status.mts

@@ -0,0 +1,50 @@
+import { sessions } from './bridge.mjs'
+import { sendTerminal } from './terminal-bridge.mjs'
+import { externalStatus } from './external-console.mjs'
+import type { PublicSession, SessionSnapshot, SessionState, ConnectionState } from './session-types.mjs'
+
+/** Probe only the authenticated local control pipe. A saved idle/running record
+ * cannot establish that its host still exists; no model request is submitted. */
+export async function sessionStatus(cwd = process.cwd()): Promise<SessionSnapshot[]> {
+  const listed = sessions(cwd)
+  return Promise.all(listed.map(async session => {
+    const base = { ...session, lastKnownState: session.state ?? null }
+    const snapshot = (state: SessionState, connection: ConnectionState, extra: Partial<PublicSession> = {}): SessionSnapshot => ({ ...base, ...extra, state, connection,
+      fullyIdle: connection === 'connected' && state === 'idle', checkedAt: new Date().toISOString() })
+    if (session.state === 'closed') return snapshot('closed', 'closed')
+    if (session.transport === 'console') {
+      try {
+        const live = externalStatus(session)
+        return snapshot(live.state, 'connected')
+      } catch { return snapshot('unknown', 'unreachable') }
+    }
+    if (!['pty', 'stdio'].includes(session.transport || '')) return snapshot('unknown', 'unverified')
+    try {
+      const raw: unknown = await sendTerminal(session.id, { action: 'status' }, null, { timeoutMs: 1000 })
+      const live = raw as Partial<PublicSession> | null
+      if (live?.id !== session.id || !live.state || !['starting', 'running', 'idle', 'awaiting_user', 'settling', 'closed'].includes(live.state)) {
+        return snapshot('unknown', 'unreachable')
+      }
+      return snapshot(live.state, 'connected', {
+        usage: live.usage === undefined ? session.usage : live.usage,
+        pendingApproval: live.pendingApproval,
+      })
+    } catch {
+      // A disconnected host or a timeout is not proof of a completed task.
+      return snapshot('unknown', 'unreachable')
+    }
+  }))
+}
+
+const labels = { starting: '시작 중', running: '작업 중', idle: '대기', awaiting_user: '승인 대기',
+  settling: '대기 전환 중', closed: '종료', unknown: '상태 미확인' }
+const connections = { connected: '연결됨', closed: '종료됨', unreachable: '연결 확인 불가', unverified: '확인 미지원' }
+const safe = (value: unknown) => String(value ?? '').replace(/[\x00-\x1f\x7f-\x9f]/g, ' ')
+
+export function formatSessionStatus(listed: readonly SessionSnapshot[]): string {
+  if (!listed.length) return '이 저장소에 등록된 로컬 세션이 없습니다.'
+  return ['axMap 세션 상태', ...listed.map(s => {
+    const usage = s.usage?.totalTokens == null ? '미확인' : `${s.usage.totalTokens}${s.maxTokens ? ` / ${s.maxTokens}` : ''}`
+    return `${safe(s.provider)}  ${safe(s.id)}\n  ${connections[s.connection] || '상태 미확인'} · ${labels[s.state] || '상태 미확인'}${s.role ? ` · ${safe(s.role)}` : ''}\n  확인된 누적 처리 토큰: ${usage}`
+  })].join('\n')
+}

package/src/session-types.mjs

@@ -0,0 +1,7 @@
+// Generated from src/session-types.mts. Edit the .mts source and run npm run build.
+export function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+export function errorCode(error) {
+    return error instanceof Error && 'code' in error && typeof error.code === 'string' ? error.code : undefined;
+}

package/src/session-types.mts

@@ -0,0 +1,118 @@
+/** Shared contracts for the local bridge. Runtime input checks still guard external data. */
+export type Provider = 'codex' | 'agy'
+export type Transport = 'console' | 'stdio' | 'pty' | 'agentapi'
+export type SessionState = 'starting' | 'running' | 'idle' | 'awaiting_user' | 'settling' | 'closed' | 'unknown'
+export type RequestState = 'sending' | 'submitted' | 'unknown' | 'completed' | 'failed' | 'superseded'
+export type ConnectionState = 'connected' | 'closed' | 'unreachable' | 'unverified'
+export type HookEvent = 'SessionStart' | 'PreInvocation' | 'Stop'
+
+export interface Usage {
+  inputTokens: number
+  cachedInputTokens: number
+  outputTokens: number
+  reasoningTokens: number
+  totalTokens: number
+  providerTotalTokens: number
+}
+export interface PendingApproval { id: string | number; method?: string; [key: string]: unknown }
+export interface SessionRecord {
+  id: string
+  provider: Provider
+  transport?: Transport
+  workspaces: string[]
+  repos: string[]
+  state?: SessionState
+  pid?: number
+  startedAt?: string
+  registeredAt: string
+  event?: string
+  fullyIdle?: boolean
+  conversationId?: string
+  transcript?: string
+  model?: string | null
+  role?: string
+  usage?: Usage | null
+  usageKnown?: boolean
+  maxTokens?: number
+  pendingApproval?: PendingApproval
+  executable?: string
+  address?: string
+  token?: string
+}
+export type PublicSession = Pick<SessionRecord, 'id' | 'provider' | 'workspaces' | 'model' | 'transport' |
+  'state' | 'pid' | 'registeredAt' | 'event' | 'fullyIdle' | 'role' | 'usage' | 'usageKnown' | 'maxTokens' | 'pendingApproval'>
+export interface SessionSnapshot extends PublicSession {
+  lastKnownState: SessionState | null
+  state: SessionState
+  connection: ConnectionState
+  checkedAt: string
+}
+export interface RequestRecord {
+  id: string
+  to: string
+  from: string
+  repo: string
+  prompt: string
+  createdAt: string
+  baseline: number | null
+  state: RequestState
+  receipt?: unknown
+  result?: unknown
+  error?: string
+  completedAt?: string
+  conversationId?: string
+  usage?: Usage | null
+}
+export interface DispatchOptions { to: string; prompt: string; cwd: string; from?: string; dialogueId?: string | null }
+export interface HookInput {
+  conversationId?: string
+  workspacePaths?: string[]
+  transcriptPath?: string
+  modelName?: string
+  fullyIdle?: boolean
+  model?: string
+  session_id?: string
+  prompt?: string
+  last_assistant_message?: unknown
+}
+export type LocalRequest = Pick<RequestRecord, 'id' | 'to' | 'prompt'> & Partial<Pick<RequestRecord, 'from'>>
+export type LocalMessage = { token?: string } & (
+  { action: 'status' } | { action: 'result'; id: string } |
+  { action: 'answer'; id: string | number; decision: string } |
+  { action: 'submit'; request: LocalRequest } |
+  { action: 'hook'; event: string; input: HookInput }
+)
+export interface JobRecord {
+  id: string; to: string; state: RequestState; result?: unknown; error?: string; completedAt?: string
+  baseline?: Usage | null; baselineKnown?: boolean; usage?: Usage | null; conversationId?: string
+  turnId?: string; rawUsage?: unknown; observed?: boolean; interrupted?: boolean
+}
+export interface TranscriptEntry { type?: string; source?: string; status?: string; content?: unknown }
+export interface ConsoleSnapshot { pid: number; startedAt: string; screen: string; ignored?: false }
+export interface DialogueTurn {
+  index: number; to: string; from: string; requestId: string; state: RequestState
+  usage?: Usage | null; conversationId?: string; error?: string; message?: string; done?: boolean
+}
+export type DialogueState = 'queued' | 'running' | 'stopping' | 'failed' | 'cancelled' | 'token_limit' |
+  'unknown' | 'usage_unavailable' | 'message_limit' | 'invalid_response' | 'completed' | 'turn_limit'
+export interface DialogueRecord {
+  id: string; repo: string; left?: string; right?: string; state: DialogueState; createdAt?: string
+  limits?: { maxTurns: number; maxTokens: number; maxMessageChars: number; timeoutMs: number }
+  turns: DialogueTurn[]; usage?: Usage | null; knownUsage?: Usage | null; usagePending?: boolean
+  reason?: string; endedAt?: string
+}
+export interface DialogueOptions {
+  id?: string; left: string; right: string; prompt: string; cwd?: string
+  maxTurns?: number; maxTokens?: number; maxMessageChars?: number; timeoutMs?: number
+  onEvent?: (event: Record<string, unknown>) => void
+  dispatch?: (options: DispatchOptions) => RequestRecord
+  result?: (id: string, cwd: string) => RequestRecord
+  inventory?: (cwd: string) => PublicSession[]
+}
+
+export function errorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error)
+}
+export function errorCode(error: unknown): string | undefined {
+  return error instanceof Error && 'code' in error && typeof error.code === 'string' ? error.code : undefined
+}

package/src/session-usage.mjs

@@ -1,34 +1,39 @@
-/** Provider counters are cumulative. Cached input and reasoning are subsets in
- * Codex, while agy reports cached reads separately from its input/total. Keep
- * both the provider total and all processed tokens; never add reasoning twice. */
-const count = value => Number.isSafeInteger(value) && value >= 0
-const fields = ['inputTokens', 'cachedInputTokens', 'outputTokens', 'reasoningTokens', 'totalTokens', 'providerTotalTokens']
-
+// Generated from src/session-usage.mts. Edit the .mts source and run npm run build.
+const count = (value) => typeof value === 'number' && Number.isSafeInteger(value) && value >= 0;
+const fields = ['inputTokens', 'cachedInputTokens', 'outputTokens', 'reasoningTokens', 'totalTokens', 'providerTotalTokens'];
 export function normalizeUsage(provider, raw) {
-  if (!raw) return null
-  const u = provider === 'codex' ? {
-    inputTokens: raw.inputTokens, cachedInputTokens: raw.cachedInputTokens,
-    outputTokens: raw.outputTokens, reasoningTokens: raw.reasoningOutputTokens,
-    totalTokens: raw.totalTokens, providerTotalTokens: raw.totalTokens,
-  } : {
-    inputTokens: raw.input_tokens, cachedInputTokens: raw.cache_read_tokens,
-    outputTokens: raw.output_tokens, reasoningTokens: raw.thinking_tokens,
-    totalTokens: count(raw.total_tokens) && count(raw.cache_read_tokens) ? raw.total_tokens + raw.cache_read_tokens : null,
-    providerTotalTokens: raw.total_tokens,
-  }
-  if (fields.some(key => !count(u[key]))) return null
-  if (provider === 'agy') u.inputTokens += u.cachedInputTokens
-  if (u.cachedInputTokens > u.inputTokens || u.reasoningTokens > u.outputTokens) return null
-  return u
+    if (!raw || typeof raw !== 'object')
+        return null;
+    const counters = raw;
+    const candidate = provider === 'codex' ? {
+        inputTokens: counters.inputTokens, cachedInputTokens: counters.cachedInputTokens,
+        outputTokens: counters.outputTokens, reasoningTokens: counters.reasoningOutputTokens,
+        totalTokens: counters.totalTokens, providerTotalTokens: counters.totalTokens,
+    } : {
+        inputTokens: counters.input_tokens, cachedInputTokens: counters.cache_read_tokens,
+        outputTokens: counters.output_tokens, reasoningTokens: counters.thinking_tokens,
+        totalTokens: count(counters.total_tokens) && count(counters.cache_read_tokens) ? counters.total_tokens + counters.cache_read_tokens : null,
+        providerTotalTokens: counters.total_tokens,
+    };
+    if (fields.some(key => !count(candidate[key])))
+        return null;
+    // All six fields have been checked above, including provider-specific counters.
+    const u = candidate;
+    if (provider === 'agy')
+        u.inputTokens += u.cachedInputTokens;
+    if (u.cachedInputTokens > u.inputTokens || u.reasoningTokens > u.outputTokens)
+        return null;
+    return u;
 }
-
 export function usageDelta(current, previous = null) {
-  if (!current) return null
-  const delta = Object.fromEntries(fields.map(k => [k, current[k] - (previous?.[k] || 0)]))
-  return fields.every(k => count(delta[k])) ? delta : null
+    if (!current)
+        return null;
+    const delta = Object.fromEntries(fields.map(k => [k, current[k] - (previous?.[k] || 0)]));
+    return fields.every(k => count(delta[k])) ? delta : null;
 }
-
 export function sumUsage(rows) {
-  if (rows.some(row => !row)) return null
-  return Object.fromEntries(fields.map(k => [k, rows.reduce((sum, row) => sum + row[k], 0)]))
+    const known = rows.filter((row) => Boolean(row));
+    if (known.length !== rows.length)
+        return null;
+    return Object.fromEntries(fields.map(k => [k, known.reduce((sum, row) => sum + row[k], 0)]));
 }

package/src/session-usage.mts

@@ -0,0 +1,39 @@
+/** Provider counters are cumulative. Cached input and reasoning are subsets in
+ * Codex, while agy reports cached reads separately from its input/total. Keep
+ * both the provider total and all processed tokens; never add reasoning twice. */
+import type { Usage, Provider } from './session-types.mjs'
+const count = (value: unknown): value is number => typeof value === 'number' && Number.isSafeInteger(value) && value >= 0
+const fields = ['inputTokens', 'cachedInputTokens', 'outputTokens', 'reasoningTokens', 'totalTokens', 'providerTotalTokens'] as const
+
+export function normalizeUsage(provider: Provider, raw: unknown): Usage | null {
+  if (!raw || typeof raw !== 'object') return null
+  const counters = raw as Record<string, unknown>
+  const candidate = provider === 'codex' ? {
+    inputTokens: counters.inputTokens, cachedInputTokens: counters.cachedInputTokens,
+    outputTokens: counters.outputTokens, reasoningTokens: counters.reasoningOutputTokens,
+    totalTokens: counters.totalTokens, providerTotalTokens: counters.totalTokens,
+  } : {
+    inputTokens: counters.input_tokens, cachedInputTokens: counters.cache_read_tokens,
+    outputTokens: counters.output_tokens, reasoningTokens: counters.thinking_tokens,
+    totalTokens: count(counters.total_tokens) && count(counters.cache_read_tokens) ? counters.total_tokens + counters.cache_read_tokens : null,
+    providerTotalTokens: counters.total_tokens,
+  }
+  if (fields.some(key => !count(candidate[key]))) return null
+  // All six fields have been checked above, including provider-specific counters.
+  const u = candidate as Usage
+  if (provider === 'agy') u.inputTokens += u.cachedInputTokens
+  if (u.cachedInputTokens > u.inputTokens || u.reasoningTokens > u.outputTokens) return null
+  return u
+}
+
+export function usageDelta(current: Usage | null, previous: Usage | null = null): Usage | null {
+  if (!current) return null
+  const delta = Object.fromEntries(fields.map(k => [k, current[k] - (previous?.[k] || 0)])) as unknown as Usage
+  return fields.every(k => count(delta[k])) ? delta : null
+}
+
+export function sumUsage(rows: ReadonlyArray<Usage | null | undefined>): Usage | null {
+  const known = rows.filter((row): row is Usage => Boolean(row))
+  if (known.length !== rows.length) return null
+  return Object.fromEntries(fields.map(k => [k, known.reduce((sum, row) => sum + row[k], 0)])) as unknown as Usage
+}