@velum-labs/routekit-daemon 0.9.4 → 0.9.6

package/dist/index.js

@@ -6,9 +6,9 @@
  * ports behind that front door; config/account reload builds a complete new
  * generation before atomically switching new traffic and draining the old.
  */
-import { chmodSync, existsSync, mkdirSync, readFileSync, rmSync } from "node:fs";
+import { chmodSync, existsSync, lstatSync, mkdirSync, readFileSync, rmSync } from "node:fs";
 import { basename, dirname, join } from "node:path";
-import { CLIPROXY_API_KEY_ENV, CLIPROXY_BASE_URL_ENV, accountStoreEntries, cliproxyAuthDirectory, cliproxyAccountEntries, cliproxyAccountMatchesKind, cliproxyApiKey, cliproxyBaseUrl, cliproxyCredentialValid, defaultSubscriptionAccountDirectory, removeCliproxyAccount, removeSubscriptionAccount, sanitizeSubscriptionLabel } from "@velum-labs/routekit-accounts";
+import { CLIPROXY_API_KEY_ENV, CLIPROXY_BASE_URL_ENV, accountStoreEntries, cliproxyAuthDirectory, cliproxyAccountEntries, cliproxyAccountMatchesKind, cliproxyApiKey, cliproxyBaseUrl, cliproxyCredentialValid, defaultSubscriptionAccountDirectory, RateLimitTracker, removeCliproxyAccount, removeSubscriptionAccount, renameSubscriptionAccount, sanitizeSubscriptionLabel } from "@velum-labs/routekit-accounts";
 import { configuredProviderIds, globalRouterConfigPath, parseRouterConfigDocument, routekitHome, writeRouterConfig } from "@velum-labs/routekit-config";
 import { createRouteKitControlHandler, ROUTEKIT_CONTROL_CAPABILITY } from "@velum-labs/routekit-control";
 import { startSwitchingGatewayProxy } from "@velum-labs/routekit-gateway";
@@ -976,6 +976,96 @@ export async function startRouteKitDaemon(options) {
                 });
                 return { removed, revision: revisions.accounts };
             },
+            "accounts.rename": async (params) => {
+                const resolved = resolveAccountConnector(params.kind);
+                if (resolved === undefined || resolved.info.connector !== "native") {
+                    throw new ControlError({
+                        code: "bad_request",
+                        message: "account rename supports only claude-code and codex"
+                    });
+                }
+                const kind = resolved.kind;
+                for (const [field, label] of [
+                    ["source", params.source],
+                    ["target", params.target]
+                ]) {
+                    if (sanitizeSubscriptionLabel(label) !== label || label.startsWith(".")) {
+                        throw new ControlError({
+                            code: "bad_request",
+                            message: `${field} account label must already be normalized`
+                        });
+                    }
+                }
+                await serializeMutation(async () => {
+                    const directory = defaultSubscriptionAccountDirectory(kind, env);
+                    const sourcePath = join(directory, `${params.source}.json`);
+                    const targetPath = join(directory, `${params.target}.json`);
+                    const trackerPath = join(directory, ".state.json");
+                    if (!existsSync(sourcePath)) {
+                        throw new ControlError({
+                            code: "not_found",
+                            message: `${kind}/${params.source} is not enrolled`
+                        });
+                    }
+                    try {
+                        lstatSync(targetPath);
+                        throw new ControlError({
+                            code: "conflict",
+                            message: `${kind}/${params.target} is already enrolled`
+                        });
+                    }
+                    catch (error) {
+                        if (error instanceof ControlError ||
+                            typeof error !== "object" ||
+                            error === null ||
+                            !("code" in error) ||
+                            error.code !== "ENOENT") {
+                            throw error;
+                        }
+                    }
+                    const transaction = prepareAccountTransaction({
+                        home,
+                        configPath,
+                        accountPaths: [sourcePath, targetPath, trackerPath],
+                        accountRoots: [directory],
+                        kind,
+                        provider: kind,
+                        labels: [params.source, params.target]
+                    });
+                    try {
+                        renameSubscriptionAccount(kind, params.source, params.target, {
+                            accountsDirectory: directory
+                        });
+                        new RateLimitTracker(trackerPath, kind).renameMember(params.source, params.target);
+                        options.onAccountTransactionPhase?.("credentials-written");
+                        await replaceRouter(currentConfig, currentDocument, {
+                            write: false,
+                            accountRevision: true,
+                            beforeSwap: () => markAccountTransactionCommitted(transaction)
+                        });
+                        try {
+                            cleanupAccountTransaction(transaction);
+                        }
+                        catch {
+                            // A committed manifest is cleanup-only on the next daemon start.
+                        }
+                    }
+                    catch (error) {
+                        const rollbackFailures = [];
+                        try {
+                            rollbackAccountTransaction(transaction, home);
+                        }
+                        catch (rollbackError) {
+                            rollbackFailures.push(rollbackError);
+                        }
+                        if (rollbackFailures.length > 0) {
+                            throw new AggregateError([error, ...rollbackFailures], `could not rename ${kind}/${params.source}; rollback failed`);
+                        }
+                        throw error;
+                    }
+                });
+                return { renamed: true, revision: revisions.accounts };
+            },
             "accounts.sync": async () => {
                 // A connector login wrote new account state outside the control
                 // channel (the cliproxy auth store); rebuild the router generation and

package/dist/test/daemon.test.js

@@ -311,6 +311,85 @@ test("singleton daemon exposes authenticated control and a stable reloadable dat
         rmSync(root, { recursive: true, force: true });
     }
 });
+for (const kind of ["claude-code", "codex"]) {
+    test(`native ${kind} account rename preserves routing and usage state`, async () => {
+        const root = mkdtempSync(join(tmpdir(), `routekit-daemon-rename-${kind}-`));
+        const stateHome = join(root, "state");
+        const configPath = join(root, "router.yaml");
+        const accountsDirectory = join(stateHome, "subscriptions", kind);
+        const sourcePath = join(accountsDirectory, "work.json");
+        const targetPath = join(accountsDirectory, "personal.json");
+        const occupiedPath = join(accountsDirectory, "occupied.json");
+        const credential = `${JSON.stringify(nativeCredential(kind))}\n`;
+        const coolingUntil = Date.now() + 60_000;
+        mkdirSync(accountsDirectory, { recursive: true });
+        writeFileSync(sourcePath, credential, { mode: 0o600 });
+        writeFileSync(join(accountsDirectory, ".state.json"), JSON.stringify({ members: [{ id: "work", coolingUntil }] }), { mode: 0o600 });
+        writeFileSync(configPath, `providers:\n  ${kind}: {}\ndefaultModel: ${kind}/${kind === "claude-code" ? "claude-test-model" : "gpt-test-model"}\n`);
+        try {
+            await withMockNativeDiscovery(kind, async () => {
+                const daemon = await startRouteKitDaemon({
+                    packageVersion: "1.2.3",
+                    stateHome,
+                    configPath,
+                    port: 0,
+                    portless: false,
+                    env: {
+                        HOME: root,
+                        ROUTEKIT_HOME: stateHome,
+                        ROUTEKIT_PORTLESS: "0"
+                    }
+                });
+                try {
+                    const client = new RouteKitControlClient({
+                        url: daemon.record.url,
+                        token: daemon.record.controlToken
+                    });
+                    const before = await client.call("daemon.status", {});
+                    const beforeConfig = await client.call("config.get", {});
+                    const renamed = await client.call("accounts.rename", { kind, source: "work", target: "personal" }, { idempotencyKey: `rename-${kind}-work` });
+                    assert.deepEqual(renamed, {
+                        renamed: true,
+                        revision: before.accountRevision + 1
+                    });
+                    assert.equal(existsSync(sourcePath), false);
+                    assert.equal(readFileSync(targetPath, "utf8"), credential);
+                    assert.deepEqual(await client.call("config.get", {}), beforeConfig);
+                    assert.deepEqual((await client.call("accounts.list", {})).accounts, [
+                        { subscriptionKind: kind, label: "personal", connector: "native" }
+                    ]);
+                    const status = await client.call("accounts.status", {});
+                    assert.equal(status.accounts[0]?.label, "personal");
+                    assert.equal(status.accounts[0]?.subscriptionKind, kind);
+                    const usage = (await client.call("accounts.usage", {}));
+                    assert.equal(usage.accountSets[0]?.members[0]?.label, "personal");
+                    assert.equal(usage.accountSets[0]?.members[0]?.coolingUntil, coolingUntil);
+                    const tracker = JSON.parse(readFileSync(join(accountsDirectory, ".state.json"), "utf8"));
+                    assert.deepEqual(tracker.members.map((member) => [member.id, member.coolingUntil]), [["personal", coolingUntil]]);
+                    assert.equal((await client.call("doctor.run", {})).checks.find((check) => check.name === "account/provider consistency")?.ok, true);
+                    const afterRename = await client.call("daemon.status", {});
+                    await assert.rejects(client.call("accounts.rename", { kind, source: "missing", target: "available" }, { idempotencyKey: `rename-${kind}-missing` }), (error) => error instanceof ControlError &&
+                        error.code === "not_found" &&
+                        /not enrolled/.test(error.message));
+                    writeFileSync(occupiedPath, credential, { mode: 0o600 });
+                    await assert.rejects(client.call("accounts.rename", { kind, source: "personal", target: "occupied" }, { idempotencyKey: `rename-${kind}-occupied` }), (error) => error instanceof ControlError &&
+                        error.code === "conflict" &&
+                        /already enrolled/.test(error.message));
+                    assert.equal(readFileSync(targetPath, "utf8"), credential);
+                    assert.equal(readFileSync(occupiedPath, "utf8"), credential);
+                    assert.deepEqual(await client.call("daemon.status", {}), afterRename);
+                    assert.equal(existsSync(join(stateHome, "account-transactions")), false);
+                }
+                finally {
+                    await daemon.close();
+                }
+            });
+        }
+        finally {
+            rmSync(root, { recursive: true, force: true });
+        }
+    });
+}
 test("native provider stays enabled until its last account is removed", async () => {
     const root = mkdtempSync(join(tmpdir(), "routekit-daemon-native-remove-"));
     const stateHome = join(root, "state");

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@velum-labs/routekit-daemon",
   "private": false,
-  "version": "0.9.4",
+  "version": "0.9.6",
   "description": "Singleton RouteKit control daemon and stable model gateway.",
   "repository": {
     "type": "git",
@@ -34,14 +34,14 @@
   ],
   "dependencies": {
     "yaml": "2.9.0",
-    "@velum-labs/routekit-config": "0.9.4",
-    "@velum-labs/routekit-gateway": "0.9.4",
-    "@velum-labs/routekit-control": "0.9.4",
-    "@velum-labs/routekit-accounts": "0.9.4",
-    "@velum-labs/routekit-registry": "0.9.4",
-    "@velum-labs/routekit-router": "0.9.4",
-    "@velum-labs/routekit-telemetry-core": "0.9.4",
-    "@velum-labs/routekit-runtime": "0.9.4"
+    "@velum-labs/routekit-accounts": "0.9.6",
+    "@velum-labs/routekit-control": "0.9.6",
+    "@velum-labs/routekit-config": "0.9.6",
+    "@velum-labs/routekit-registry": "0.9.6",
+    "@velum-labs/routekit-router": "0.9.6",
+    "@velum-labs/routekit-gateway": "0.9.6",
+    "@velum-labs/routekit-runtime": "0.9.6",
+    "@velum-labs/routekit-telemetry-core": "0.9.6"
   },
   "scripts": {
     "build": "tsc -b",