vibe-coding-master 0.2.5 → 0.2.7

package/dist/backend/gateway/gateway-settings-service.js

@@ -0,0 +1,214 @@
+import path from "node:path";
+import { homedir } from "node:os";
+const DEFAULT_BASE_URL = "https://ilinkai.weixin.qq.com";
+const MAX_DEDUPE_IDS = 1000;
+export function createGatewaySettingsService(deps) {
+    const settingsPath = deps.settingsPath ?? path.join(homedir(), ".vcm", "gateway", "settings.json");
+    const auditPath = deps.auditPath ?? path.join(homedir(), ".vcm", "gateway", "audit.jsonl");
+    const now = deps.now ?? (() => new Date().toISOString());
+    let cachedSettings = null;
+    async function loadSettings() {
+        if (cachedSettings) {
+            return cachedSettings;
+        }
+        if (!(await deps.fs.pathExists(settingsPath))) {
+            cachedSettings = normalizeSettings({}, now());
+            await saveSettings(cachedSettings);
+            return cachedSettings;
+        }
+        cachedSettings = normalizeSettings(await deps.fs.readJson(settingsPath), now());
+        return cachedSettings;
+    }
+    async function saveSettings(settings) {
+        cachedSettings = normalizeSettings(settings, now());
+        await deps.fs.writeJsonAtomic(settingsPath, cachedSettings);
+        return cachedSettings;
+    }
+    return {
+        loadSettings,
+        async updateSettings(input) {
+            const current = await loadSettings();
+            return saveSettings({
+                ...current,
+                enabled: input.enabled ?? current.enabled,
+                translationEnabled: input.translationEnabled ?? current.translationEnabled,
+                currentProjectId: input.currentProjectId !== undefined ? normalizeNullableString(input.currentProjectId) : current.currentProjectId,
+                currentTaskSlug: input.currentTaskSlug !== undefined ? normalizeNullableString(input.currentTaskSlug) : current.currentTaskSlug,
+                updatedAt: now()
+            });
+        },
+        saveSettings,
+        async resetBinding() {
+            const current = await loadSettings();
+            return saveSettings({
+                ...current,
+                enabled: false,
+                binding: createDefaultBinding(),
+                dedupe: {
+                    recentInboundMessageIds: []
+                },
+                pushCursors: {},
+                lastPollStatus: {
+                    state: "idle"
+                },
+                lastMessageStatus: null,
+                updatedAt: now()
+            });
+        },
+        expose(settings, running = false) {
+            return {
+                version: 1,
+                enabled: settings.enabled,
+                running,
+                channel: settings.channel,
+                translationEnabled: settings.translationEnabled,
+                currentProjectId: settings.currentProjectId,
+                currentTaskSlug: settings.currentTaskSlug,
+                binding: {
+                    accountId: settings.binding.accountId,
+                    baseUrl: settings.binding.baseUrl,
+                    boundUserId: settings.binding.boundUserId,
+                    loginUserId: settings.binding.loginUserId,
+                    tokenConfigured: Boolean(settings.binding.token)
+                },
+                pendingConfirmations: settings.pendingConfirmations,
+                lastPollStatus: settings.lastPollStatus,
+                lastMessageStatus: settings.lastMessageStatus,
+                updatedAt: settings.updatedAt
+            };
+        },
+        getSettingsPath() {
+            return settingsPath;
+        },
+        getAuditPath() {
+            return auditPath;
+        }
+    };
+}
+export function normalizeSettings(input, timestamp) {
+    const bindingInput = isObject(input.binding) ? input.binding : {};
+    const dedupeInput = isObject(input.dedupe) ? input.dedupe : {};
+    const pendingInput = isObject(input.pendingConfirmations)
+        ? input.pendingConfirmations
+        : {};
+    const pushCursors = isObject(input.pushCursors) ? input.pushCursors : {};
+    return {
+        version: 1,
+        enabled: input.enabled === true,
+        channel: "weixin-ilink",
+        translationEnabled: input.translationEnabled !== false,
+        currentProjectId: normalizeNullableString(input.currentProjectId),
+        currentTaskSlug: normalizeNullableString(input.currentTaskSlug),
+        binding: {
+            ...createDefaultBinding(),
+            accountId: normalizeNullableString(bindingInput.accountId),
+            baseUrl: normalizeBaseUrl(bindingInput.baseUrl),
+            boundUserId: normalizeNullableString(bindingInput.boundUserId),
+            loginUserId: normalizeNullableString(bindingInput.loginUserId),
+            token: normalizeNullableString(bindingInput.token),
+            getUpdatesBuf: typeof bindingInput.getUpdatesBuf === "string" ? bindingInput.getUpdatesBuf : "",
+            contextTokens: isObject(bindingInput.contextTokens)
+                ? normalizeStringRecord(bindingInput.contextTokens)
+                : {}
+        },
+        dedupe: {
+            recentInboundMessageIds: Array.isArray(dedupeInput.recentInboundMessageIds)
+                ? dedupeInput.recentInboundMessageIds.filter((value) => typeof value === "string").slice(-MAX_DEDUPE_IDS)
+                : []
+        },
+        pendingConfirmations: {
+            closeTask: normalizeCloseTaskConfirmation(pendingInput.closeTask)
+        },
+        pushCursors: normalizePushCursors(pushCursors),
+        lastPollStatus: normalizePollStatus(input.lastPollStatus),
+        lastMessageStatus: normalizeMessageStatus(input.lastMessageStatus),
+        updatedAt: typeof input.updatedAt === "string" ? input.updatedAt : timestamp
+    };
+}
+function createDefaultBinding() {
+    return {
+        accountId: null,
+        baseUrl: DEFAULT_BASE_URL,
+        boundUserId: null,
+        loginUserId: null,
+        token: null,
+        getUpdatesBuf: "",
+        contextTokens: {}
+    };
+}
+function normalizeCloseTaskConfirmation(input) {
+    if (!isObject(input)) {
+        return null;
+    }
+    const taskSlug = normalizeNullableString(input.taskSlug);
+    const createdAt = normalizeNullableString(input.createdAt);
+    const expiresAt = normalizeNullableString(input.expiresAt);
+    if (!taskSlug || !createdAt || !expiresAt) {
+        return null;
+    }
+    return { taskSlug, createdAt, expiresAt };
+}
+function normalizePushCursors(input) {
+    const out = {};
+    for (const [key, value] of Object.entries(input)) {
+        if (!isObject(value)) {
+            continue;
+        }
+        out[key] = {
+            lastTranscriptEventId: normalizeNullableString(value.lastTranscriptEventId),
+            lastTranscriptTimestamp: normalizeNullableString(value.lastTranscriptTimestamp)
+        };
+    }
+    return out;
+}
+function normalizePollStatus(input) {
+    if (!isObject(input)) {
+        return { state: "idle" };
+    }
+    const state = input.state === "running" || input.state === "error" || input.state === "expired"
+        ? input.state
+        : "idle";
+    return {
+        state,
+        checkedAt: normalizeNullableString(input.checkedAt) ?? undefined,
+        error: normalizeNullableString(input.error) ?? undefined
+    };
+}
+function normalizeMessageStatus(input) {
+    if (!isObject(input)) {
+        return null;
+    }
+    return {
+        checkedAt: normalizeNullableString(input.checkedAt) ?? undefined,
+        direction: input.direction === "inbound" || input.direction === "outbound" ? input.direction : undefined,
+        command: normalizeNullableString(input.command) ?? undefined,
+        result: input.result === "ok" || input.result === "ignored" || input.result === "error" ? input.result : undefined,
+        preview: normalizeNullableString(input.preview) ?? undefined,
+        error: normalizeNullableString(input.error) ?? undefined
+    };
+}
+function normalizeBaseUrl(input) {
+    const raw = typeof input === "string" ? input.trim() : "";
+    if (!raw) {
+        return DEFAULT_BASE_URL;
+    }
+    if (raw.startsWith("http://") || raw.startsWith("https://")) {
+        return raw.replace(/\/+$/, "");
+    }
+    return `https://${raw.replace(/\/+$/, "")}`;
+}
+function normalizeNullableString(input) {
+    return typeof input === "string" && input.trim() ? input.trim() : null;
+}
+function normalizeStringRecord(input) {
+    const out = {};
+    for (const [key, value] of Object.entries(input)) {
+        if (typeof value === "string") {
+            out[key] = value;
+        }
+    }
+    return out;
+}
+function isObject(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}

package/dist/backend/server.js

@@ -14,6 +14,11 @@ import { createHarnessService, createScriptFixedHarnessInstaller } from "./servi
 import { createNodeFileSystemAdapter } from "./adapters/filesystem.js";
 import { createNodePtyTerminalRuntime } from "./runtime/node-pty-runtime.js";
 import { createOpenAiCompatibleTranslationProvider } from "./adapters/translation-provider.js";
+import { registerGatewayRoutes } from "./api/gateway-routes.js";
+import { createWeixinIlinkChannel } from "./gateway/channels/weixin-ilink-channel.js";
+import { createGatewayAuditLog } from "./gateway/gateway-audit-log.js";
+import { createGatewayService } from "./gateway/gateway-service.js";
+import { createGatewaySettingsService } from "./gateway/gateway-settings-service.js";
 import { createProjectService } from "./services/project-service.js";
 import { createSessionRegistry } from "./runtime/session-registry.js";
 import { createSessionService } from "./services/session-service.js";
@@ -90,7 +95,14 @@ export async function createServer(deps, options = {}) {
         taskService: deps.taskService,
         translationService: deps.translationService
     });
+    registerGatewayRoutes(app, { gatewayService: deps.gatewayService });
     registerTerminalWs(app, { runtime: deps.runtime });
+    app.addHook("onReady", async () => {
+        await deps.gatewayService.start();
+    });
+    app.addHook("onClose", async () => {
+        deps.gatewayService.stop();
+    });
     if (options.staticDir) {
         await app.register(fastifyStatic, {
             root: options.staticDir,
@@ -162,7 +174,12 @@ export function createDefaultServerDeps(options = {}) {
         sessionService,
         taskService
     });
-    const roundService = createRoundService({ fs });
+    const roundService = createRoundService({
+        fs,
+        onSessionStatusChange: async ({ repoRoot, taskSlug, status }) => {
+            await taskService.updateTaskStatus(repoRoot, taskSlug, status);
+        }
+    });
     const transcripts = createClaudeTranscriptService();
     const translationService = createTranslationService({
         runtime,
@@ -174,6 +191,25 @@ export function createDefaultServerDeps(options = {}) {
         appSettings,
         provider: createOpenAiCompatibleTranslationProvider()
     });
+    const gatewaySettings = createGatewaySettingsService({ fs });
+    const gatewayAudit = createGatewayAuditLog({
+        fs,
+        auditPath: gatewaySettings.getAuditPath()
+    });
+    const gatewayService = createGatewayService({
+        fs,
+        settings: gatewaySettings,
+        audit: gatewayAudit,
+        channel: createWeixinIlinkChannel(),
+        projectService,
+        taskService,
+        sessionService,
+        messageService,
+        translationService,
+        roundService,
+        runtime,
+        appSettings
+    });
     const claudeHookService = createClaudeHookService({
         projectService,
         taskService,
@@ -181,7 +217,8 @@ export function createDefaultServerDeps(options = {}) {
         messageService,
         roundService,
         translationService,
-        appSettings
+        appSettings,
+        gatewayService
     });
     return {
         appSettings,
@@ -196,6 +233,7 @@ export function createDefaultServerDeps(options = {}) {
         roundService,
         statusService,
         translationService,
+        gatewayService,
         runtime
     };
 }

package/dist/backend/services/claude-hook-service.js

@@ -43,6 +43,7 @@ export function createClaudeHookService(deps) {
             cwd: stringOrUndefined(input.event.cwd)
         });
         await deps.roundService.recordClaudeHookEvent({
+            repoRoot: context.project.repoRoot,
             stateRepoRoot: context.taskRepoRoot,
             stateRoot: context.config.stateRoot,
             taskSlug: input.taskSlug,
@@ -57,7 +58,7 @@ export function createClaudeHookService(deps) {
                 role: input.role,
                 sessionId: session.id,
                 boundaryKind: "start",
-                occurredAt: session.lastPromptSubmittedAt ?? session.updatedAt
+                occurredAt: session.lastTurnStartedAt ?? session.updatedAt
             });
         }
         const submitted = await deps.messageService.confirmPromptSubmitted({
@@ -112,6 +113,7 @@ export function createClaudeHookService(deps) {
             cwd: stringOrUndefined(input.event.cwd)
         });
         await deps.roundService.recordClaudeHookEvent({
+            repoRoot: context.project.repoRoot,
             stateRepoRoot: context.taskRepoRoot,
             stateRoot: context.config.stateRoot,
             taskSlug: input.taskSlug,
@@ -120,12 +122,12 @@ export function createClaudeHookService(deps) {
             settleGuard: async () => {
                 const pending = await deps.messageService.listPendingRouteFiles(settleRouteDispatchInput);
                 if (pending.length === 0) {
-                    return { action: "pause" };
+                    return { action: "stop" };
                 }
                 const retried = await deps.messageService.scanAndDispatchPendingRouteFiles(settleRouteDispatchInput);
                 return retried.some((result) => result.delivered)
                     ? { action: "continue", reason: "pending route message dispatched" }
-                    : { action: "pause" };
+                    : { action: "stop" };
             }
         });
         if (session) {
@@ -136,9 +138,16 @@ export function createClaudeHookService(deps) {
                 role: input.role,
                 sessionId: session.id,
                 boundaryKind: "end",
-                occurredAt: session.lastStopAt ?? session.updatedAt
+                occurredAt: session.lastTurnEndedAt ?? session.updatedAt
             });
         }
+        if (session && input.role === "project-manager") {
+            void deps.gatewayService?.handlePmStop({
+                repoRoot: context.project.repoRoot,
+                taskSlug: input.taskSlug,
+                session
+            }).catch(() => undefined);
+        }
         const dispatched = await deps.messageService.scanAndDispatchPendingRouteFiles(scopedRouteDispatchInput);
         return {
             ok: true,

package/dist/backend/services/project-service.js

@@ -33,38 +33,43 @@ export function createProjectService(deps) {
             await deps.fs.ensureDir(path.join(this.getProjectDataRoot(repoRoot), "tasks"));
             await deps.fs.ensureDir(path.join(repoRoot, ".claude", "worktrees"));
             await this.saveConfig(config, true);
-            const warnings = [];
-            let branch = "unknown";
-            let isDirty = false;
-            try {
-                branch = await deps.git.getCurrentBranch(repoRoot);
-            }
-            catch (caught) {
-                warnings.push(`Unable to read current Git branch. ${getErrorHint(caught)}`);
-            }
-            try {
-                isDirty = await deps.git.isDirty(repoRoot);
-            }
-            catch (caught) {
-                warnings.push(`Unable to read Git dirty status. ${getErrorHint(caught)}`);
-            }
-            if (branch === "main" || branch === "master") {
-                warnings.push(`You are on ${branch}. Consider creating a task branch before coding.`);
-            }
-            if (!(await deps.claude.isAvailable(config.claudeCommand))) {
-                warnings.push("Claude Code command is not available. You can still inspect artifacts, but sessions will not start.");
-            }
-            currentProject = {
-                repoRoot,
-                branch,
-                isDirty,
-                config,
-                warnings
-            };
+            currentProject = await readConnectedProjectSummary(repoRoot, config);
             await deps.appSettings.recordRecentRepositoryPath(repoRoot);
             return currentProject;
         },
         async getCurrentProject() {
+            if (currentProject) {
+                currentProject = await readConnectedProjectSummary(currentProject.repoRoot, currentProject.config);
+            }
+            return currentProject;
+        },
+        async pullCurrentProject() {
+            if (!currentProject) {
+                throw new VcmError({
+                    code: "NO_PROJECT",
+                    message: "No connected repository.",
+                    statusCode: 409
+                });
+            }
+            const beforePull = await readConnectedProjectSummary(currentProject.repoRoot, currentProject.config);
+            if (beforePull.isDirty) {
+                throw new VcmError({
+                    code: "BASE_REPO_DIRTY",
+                    message: "The connected repository has uncommitted changes.",
+                    statusCode: 409,
+                    hint: "Commit, stash, or discard base repository changes before pulling."
+                });
+            }
+            if (!beforePull.upstreamBranch) {
+                throw new VcmError({
+                    code: "NO_UPSTREAM",
+                    message: "The connected repository branch has no upstream.",
+                    statusCode: 409,
+                    hint: "Set an upstream branch before using Pull."
+                });
+            }
+            await deps.git.pullFastForward(currentProject.repoRoot);
+            currentProject = await readConnectedProjectSummary(currentProject.repoRoot, currentProject.config);
             return currentProject;
         },
         async getRecentRepositoryPaths() {
@@ -92,6 +97,77 @@ export function createProjectService(deps) {
             return path.dirname(deps.appSettings.getProjectConfigPath(repoRoot));
         }
     };
+    async function readConnectedProjectSummary(repoRoot, config) {
+        const warnings = [];
+        let branch = "unknown";
+        let isDirty = false;
+        let headCommit = "unknown";
+        let upstreamBranch = null;
+        let ahead = null;
+        let behind = null;
+        try {
+            branch = await deps.git.getCurrentBranch(repoRoot);
+        }
+        catch (caught) {
+            warnings.push(`Unable to read current Git branch. ${getErrorHint(caught)}`);
+        }
+        try {
+            isDirty = await deps.git.isDirty(repoRoot);
+        }
+        catch (caught) {
+            warnings.push(`Unable to read Git dirty status. ${getErrorHint(caught)}`);
+        }
+        try {
+            headCommit = await deps.git.getHeadCommit(repoRoot);
+        }
+        catch (caught) {
+            warnings.push(`Unable to read current Git commit. ${getErrorHint(caught)}`);
+        }
+        try {
+            upstreamBranch = await deps.git.getUpstreamBranch(repoRoot);
+        }
+        catch (caught) {
+            warnings.push(`Unable to read Git upstream branch. ${getErrorHint(caught)}`);
+        }
+        if (upstreamBranch) {
+            try {
+                const status = await deps.git.getAheadBehind(repoRoot, upstreamBranch);
+                ahead = status.ahead;
+                behind = status.behind;
+            }
+            catch (caught) {
+                warnings.push(`Unable to read Git ahead/behind status. ${getErrorHint(caught)}`);
+            }
+        }
+        if (!(await deps.claude.isAvailable(config.claudeCommand))) {
+            warnings.push("Claude Code command is not available. You can still inspect artifacts, but sessions will not start.");
+        }
+        const pullDisabledReason = getPullDisabledReason({ isDirty, upstreamBranch });
+        return {
+            repoRoot,
+            branch,
+            isDirty,
+            headCommit,
+            shortHeadCommit: headCommit === "unknown" ? "unknown" : headCommit.slice(0, 12),
+            upstreamBranch,
+            ahead,
+            behind,
+            canPull: !pullDisabledReason,
+            pullDisabledReason,
+            checkedAt: new Date().toISOString(),
+            config,
+            warnings
+        };
+    }
+}
+function getPullDisabledReason(input) {
+    if (input.isDirty) {
+        return "Base repository has uncommitted changes.";
+    }
+    if (!input.upstreamBranch) {
+        return "Current branch has no upstream.";
+    }
+    return undefined;
 }
 function getErrorHint(caught) {
     if (caught instanceof VcmError) {