@rubytech/create-maxy-code 0.1.442 → 0.1.444

package/payload/platform/services/claude-session-manager/dist/http-server.js

@@ -34,11 +34,13 @@ import { resolveSpawnUserId, formatMcpUserBindingLine } from './mcp-user-binding
 import { runConnectorAuthLogin } from './connector-auth.js';
 import { isEffortLevel, isNewSessionEffortLevel, isPermissionMode, SONNET_MODEL } from '../../../lib/models/dist/index.js';
 import { spawnClaudeSession, stopSession, writeInterruptToPty, isLive, onPtyExit, livePtyCount, liveSessionIds, getPtyTrackerForTests, livePidForSession, classifyLiveness, priorExitedCountForSession, PERMISSION_MODES, openFdCount, registerRcSpawnPty, } from './pty-spawner.js';
+import { parseWorkServerRegistration, formatSpawnToolsLine } from './passive-spawn-tools-tail.js';
 import { writeScopeRecord, removeScopeRecord, readAllScopeRecords } from './scope-record.js';
 import { writeReseatMarker, resolveReseatChain, clearReseatMarker } from './reseat-ledger.js';
 import { getScopeMainPid, defaultProcessSignals, defaultSystemctlRunner } from './systemd-scope.js';
 import { readSidecar, updateSidecar, appendBridgeId, writeSidecar } from './session-sidecar.js';
 import { houseAdminScopeFor, isHouseAccount, formatHouseScopeInjectLine } from './config.js';
+import { resolvePassiveAssignee, readHouseAdminUserIds } from './passive-admin-assignment.js';
 import { resolveSettingsPermissionMode, resolveSettingsModel, resolveSettingsEffort } from './settings-permission-mode.js';
 import { emitRcLife } from './rc-life.js';
 import { createRcChildLog } from './rc-child-log.js';
@@ -47,7 +49,7 @@ import { createRcChildLog } from './rc-child-log.js';
 import { extractVoiceSection } from './system-prompt.js';
 import { readJsonlSession, readJsonlSessionAtPath } from './jsonl-enumerator.js';
 import { computeMetering } from './session-metering.js';
-import { claudeStateRoot, projectSlugForCwd, jsonlPathForSessionId, sidecarPathForSessionId, permissionModeLogPathForSessionId, findExistingJsonlForSessionId, slugForExistingJsonl, jsonlPathForSlug, sidecarPathForSlug, detectRemoteControlSlug, classifyBindBlocker, classifyChildAuth, } from './jsonl-path.js';
+import { claudeStateRoot, projectSlugForCwd, jsonlPathForSessionId, sidecarPathForSessionId, permissionModeLogPathForSessionId, mcpDebugLogPathForSessionId, findExistingJsonlForSessionId, slugForExistingJsonl, jsonlPathForSlug, sidecarPathForSlug, detectRemoteControlSlug, classifyBindBlocker, classifyChildAuth, } from './jsonl-path.js';
 import { basename, dirname, join } from 'node:path';
 import { validateUserTitle } from './user-title-store.js';
 import { credentialsPathForConfigDir, snapshotAuthForFailureReason } from './auth-snapshot.js';
@@ -552,6 +554,37 @@ export function attachPassiveEndTurnAutoClose(deps, sessionId, passive) {
         return;
     attachEndTurnAutoClose(deps, sessionId, 'wa-passive');
 }
+// Task 1639 — emit the passive spawn's tool-registration post-condition once, at PTY
+// exit (by then the one-shot turn is over and the MCP connection has long resolved, so
+// the `--debug=mcp` capture is fully written). This is the REALIZED `work` surface —
+// distinct from the configured `--allowed-tools` the `op=spawn` census logs. `work-create`
+// is derived from the `work` server connecting with `hasTools` (it exposes exactly that
+// one tool under `--strict-mcp-config`). `assignedAdminEnv` records whether the managing-
+// admin id was threaded, so a missing `op=assign` is attributable (env-not-threaded vs.
+// code-broken). Passive spawns only.
+export function attachPassiveSpawnToolsCensus(deps, spawnCwd, sessionId, passive, assignedAdminEnv) {
+    if (!passive)
+        return;
+    const emit = () => {
+        // Read from the SAME cwd the spawn wrote the debug file to. A passive intake
+        // with a targetAccountId overrides spawnCwd to the sub-account (Task 1490);
+        // `deps.spawnCwd` is the house cwd, so reading it would always miss the file
+        // and report work-create=false unconditionally. Take the spawn's cwd explicitly.
+        const logPath = mcpDebugLogPathForSessionId(spawnCwd, sessionId);
+        let content = '';
+        try {
+            if (existsSync(logPath))
+                content = readFileSync(logPath, 'utf8');
+        }
+        catch { /* absent -> all-false */ }
+        const reg = parseWorkServerRegistration(content);
+        deps.logger(formatSpawnToolsLine({ sessionId, reg, assignedAdminEnv }) + '\n');
+    };
+    // Fire once at PTY exit. If no live tracker exists (a fast-failing spawn already
+    // exited before attach), emit immediately so exactly one census line is produced.
+    if (!onPtyExit(sessionId, emit))
+        emit();
+}
 function attachPublicAudit(deps, sessionId, role) {
     if (role !== 'public')
         return;
@@ -1086,11 +1119,15 @@ export function buildHttpApp(deps) {
         // ignored here too, so the transcript scope can never diverge from the
         // work-MCP graph scope (which only sub-scopes under the same invariant).
         let spawnCwd = deps.spawnCwd;
-        // Task 1500 — the target sub-account's managing admin userId, read from its
-        // account.json in the validated-target branch below and threaded into the
-        // passive spawn so work-create links the intake :Task ASSIGNED_TO that admin.
-        // Undefined when the sub-account has no managing admin (created before the
-        // enforcement change — the account-admin census flags it).
+        // Task 1500/1630 — the house admin the passive intake :Task is ASSIGNED_TO,
+        // threaded into the spawn so work-create links the edge. The sub-account's
+        // `managingAdminUserId` is authoritative when it still names a live house
+        // admin; when it is absent or dangling (admin removed after assignment) the
+        // task falls back to the install's PRIMARY admin — the first house admin, the
+        // platform owner. A managing admin is not required per client (Task 1630
+        // removed the standing account-admin census); the fallback self-heals the
+        // assignment so the task always lands on a real admin. Undefined only when the
+        // install has no live house admin at all (genuine drift — no edge is written).
         let assignedAdminUserId;
         if (passive && role === 'public' && !specialist && targetAccountId) {
             const accountsRoot = join(dirname(deps.platformRoot), 'data', 'accounts');
@@ -1100,15 +1137,19 @@ export function buildHttpApp(deps) {
                 timed(deps.logger, 'POST', '/public-spawn', 400, Date.now() - start);
                 return c.json({ error: 'targetAccountId not in this install registry' }, 400);
             }
+            let managingAdminUserId;
             try {
                 const cfg = JSON.parse(readFileSync(accountJsonPath, 'utf8'));
                 if (typeof cfg.managingAdminUserId === 'string' && cfg.managingAdminUserId) {
-                    assignedAdminUserId = cfg.managingAdminUserId;
+                    managingAdminUserId = cfg.managingAdminUserId;
                 }
             }
             catch {
-                // unparseable account.json — leave assignedAdminUserId undefined (no edge)
+                // unparseable account.json — treat as no managing admin (fall back below)
             }
+            const assignee = resolvePassiveAssignee(managingAdminUserId, readHouseAdminUserIds(accountsRoot));
+            assignedAdminUserId = assignee.userId;
+            deps.logger(`[wa-passive] op=assign-resolve target=${targetAccountId} source=${assignee.source} admin=${assignee.userId ?? '-'}`);
             spawnCwd = join(accountsRoot, targetAccountId);
         }
         const result = await spawnClaudeSession({
@@ -1127,6 +1168,7 @@ export function buildHttpApp(deps) {
                 }
                 attachSpecialistEndTurnAutoArchive(deps, tracker.sessionId, tracker.specialist);
                 attachPassiveEndTurnAutoClose(deps, tracker.sessionId, passive);
+                attachPassiveSpawnToolsCensus(deps, spawnCwd, tracker.sessionId, passive, Boolean(assignedAdminUserId));
             },
             onUrlCaptured: notifyUrlCaptured,
             tunnelUrlOverride,
@@ -1457,6 +1499,55 @@ export function buildHttpApp(deps) {
         }
         const row = resolveRow(deps.watcher, id);
         if (!row) {
+            // Task 1603 — the fs-watcher is armed to one account's project dir (the
+            // boot/house account), so a sub-account session lands under a slug the
+            // watcher never enumerates and resolveRow returns nothing. Before 404ing,
+            // resolve the JSONL by the same all-slug scan the row path (Task 1565) and
+            // the transcript use: a session whose file is on disk must never 404 the
+            // footer, only a session id with no JSONL anywhere. The payload is built
+            // rowless (no live PTY, no channel/role) — the footer reads model/effort/
+            // turns/tokens, all from the scanned tail plus the settings-resolved effort.
+            const scanPath = findExistingJsonlForSessionId(deps.claudeConfigDir, id);
+            const enriched = scanPath ? readJsonlSessionAtPath(scanPath, id, deps.jsonlReadMaxBytes, deps.logger) : null;
+            if (scanPath && enriched) {
+                const effortLevel = resolveSettingsEffort(deps.claudeConfigDir);
+                const rowlessPayload = {
+                    sessionId: id,
+                    pid: null,
+                    url: null,
+                    startedAt: enriched.startedAt,
+                    senderId: '',
+                    role: null,
+                    channel: null,
+                    jsonlPath: enriched.jsonlPath,
+                    status: 'ended',
+                    // The scan returns the archive path as `<slug>/archive/<id>.jsonl`, so
+                    // anchor to the file's immediate parent — a bare /archive/ test would
+                    // also match an ancestor dir that happens to be named "archive".
+                    archived: /\/archive\/[^/]+\.jsonl$/.test(scanPath),
+                    displayName: enriched.displayName,
+                    titleSource: enriched.titleSource,
+                    lastMessageAt: enriched.lastMessageAt,
+                    turnCount: enriched.turnCount,
+                    capped: enriched.capped,
+                    sizeBytes: enriched.sizeBytes,
+                    hidden: false,
+                    specialist: null,
+                    model: enriched.model,
+                    permissionMode: null,
+                    effectivePermissionMode: null,
+                    activity: 'idle',
+                    usedTokens: enriched.usedTokens,
+                    effortLevel,
+                };
+                deps.logger(`[session-meta] op=enrich session=${id.slice(0, 8)} resolver=scan row=absent jsonl=found model=${rowlessPayload.model ?? 'null'} effort=${effortLevel ?? 'null'} turns=${rowlessPayload.turnCount ?? 0}`);
+                timed(deps.logger, 'GET', `/${id}/meta`, 200, Date.now() - start);
+                return c.json(rowlessPayload, 200);
+            }
+            // 404 with an honest jsonl token: `absent` when the scan found nothing,
+            // `found` when it did but enrichment failed (the file vanished between the
+            // scan and the read — a real read/scan divergence, not a missing file).
+            deps.logger(`[session-meta] op=enrich session=${id.slice(0, 8)} resolver=none row=absent jsonl=${scanPath ? 'found' : 'absent'} model=null effort=null turns=0`);
             timed(deps.logger, 'GET', `/${id}/meta`, 404, Date.now() - start);
             return c.json({ error: 'session-not-found' }, 404);
         }