源码快照 @ 2026-09-01 (source-only, 剔除非源码素材)
Dependency audit / audit (push) Canceled after 0s
CI / plan (push) Canceled after 0s
Gitoxide helper admission / macos-latest (push) Canceled after 0s
Gitoxide helper admission / ubuntu-latest (push) Canceled after 0s
Gitoxide helper admission / windows-latest (push) Canceled after 0s
Runtime Host peer admission / quality (push) Canceled after 0s
Windows recovery / windows_recovery (push) Canceled after 0s
CI / heavy (push) Canceled after 0s
CI / test (push) Canceled after 0s
Dependency audit / audit (push) Canceled after 0s
CI / plan (push) Canceled after 0s
Gitoxide helper admission / macos-latest (push) Canceled after 0s
Gitoxide helper admission / ubuntu-latest (push) Canceled after 0s
Gitoxide helper admission / windows-latest (push) Canceled after 0s
Runtime Host peer admission / quality (push) Canceled after 0s
Windows recovery / windows_recovery (push) Canceled after 0s
CI / heavy (push) Canceled after 0s
CI / test (push) Canceled after 0s
This commit is contained in:
commit
7be535059e
3358 files changed
+1306357
No files matched your search
@@ -0,0 +1,336 @@
|
||||
/*
|
||||
* Licensed to the Apache Software Foundation (ASF) under one
|
||||
* or more contributor license agreements. See the NOTICE file
|
||||
* distributed with this work for additional information
|
||||
* regarding copyright ownership. The ASF licenses this file
|
||||
* to you under the Apache License, Version 2.0 (the
|
||||
* "License"); you may not use this file except in compliance
|
||||
* with the License. You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing,
|
||||
* software distributed under the License is distributed on an
|
||||
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
|
||||
* KIND, either express or implied. See the License for the
|
||||
* specific language governing permissions and limitations
|
||||
* under the License.
|
||||
*/
|
||||
|
||||
import assert from 'node:assert/strict';
|
||||
import { chmod, mkdir, mkdtemp, readdir, readFile, rm, stat, writeFile } from 'node:fs/promises';
|
||||
import { tmpdir } from 'node:os';
|
||||
import { join } from 'node:path';
|
||||
import { describe, test } from 'node:test';
|
||||
import {
|
||||
CREDENTIAL_SCHEMA_VERSION,
|
||||
createFileCredentialStore,
|
||||
withCredentialFileLock,
|
||||
type CredentialCasResult,
|
||||
type CredentialKind,
|
||||
type CredentialStore,
|
||||
} from '../credential-store.js';
|
||||
|
||||
const isPosix = process.platform !== 'win32';
|
||||
|
||||
async function withTempDir<T>(fn: (dir: string) => Promise<T>): Promise<T> {
|
||||
const dir = await mkdtemp(join(tmpdir(), 'maka-cred-'));
|
||||
try {
|
||||
return await fn(dir);
|
||||
} finally {
|
||||
await rm(dir, { recursive: true, force: true });
|
||||
}
|
||||
}
|
||||
|
||||
describe('FileCredentialStore', () => {
|
||||
test('round-trips secrets and returns null for missing ones', async () => {
|
||||
await withTempDir(async (dir) => {
|
||||
const store = createFileCredentialStore(dir);
|
||||
assert.equal(await store.getSecret('openai-prod', 'api_key'), null);
|
||||
|
||||
await store.setSecret('openai-prod', 'api_key', 'sk-test-123');
|
||||
assert.equal(await store.getSecret('openai-prod', 'api_key'), 'sk-test-123');
|
||||
|
||||
await store.deleteSecret('openai-prod', 'api_key');
|
||||
assert.equal(await store.getSecret('openai-prod', 'api_key'), null);
|
||||
});
|
||||
});
|
||||
|
||||
test('deleteSecret(slug) with no kind clears every kind for that slug only', async () => {
|
||||
await withTempDir(async (dir) => {
|
||||
const store = createFileCredentialStore(dir);
|
||||
await store.setSecret('a', 'api_key', 'key-a');
|
||||
await store.setSecret('a', 'oauth_token', 'tok-a');
|
||||
await store.setSecret('b', 'api_key', 'key-b');
|
||||
|
||||
await store.deleteSecret('a');
|
||||
|
||||
assert.equal(await store.getSecret('a', 'api_key'), null);
|
||||
assert.equal(await store.getSecret('a', 'oauth_token'), null);
|
||||
assert.equal(await store.getSecret('b', 'api_key'), 'key-b');
|
||||
});
|
||||
});
|
||||
|
||||
test('writes a versioned, plaintext (file-first) file', async () => {
|
||||
await withTempDir(async (dir) => {
|
||||
const store = createFileCredentialStore(dir);
|
||||
await store.setSecret('openai-prod', 'api_key', 'sk-plain');
|
||||
|
||||
const raw = JSON.parse(await readFile(join(dir, 'credentials.json'), 'utf8')) as {
|
||||
version: number;
|
||||
values: Record<string, string>;
|
||||
};
|
||||
assert.equal(raw.version, CREDENTIAL_SCHEMA_VERSION);
|
||||
// File-first: the value is stored as plaintext, not encoded.
|
||||
assert.equal(raw.values['openai-prod:apiKey'], 'sk-plain');
|
||||
});
|
||||
});
|
||||
|
||||
test('reading an unknown / pre-migration schema fails closed', async () => {
|
||||
await withTempDir(async (dir) => {
|
||||
const path = join(dir, 'credentials.json');
|
||||
|
||||
// Legacy file: no `version` field (the safeStorage-era shape).
|
||||
await writeFile(path, JSON.stringify({ values: { 'x:apiKey': 'enc' } }), 'utf8');
|
||||
const legacy = createFileCredentialStore(dir);
|
||||
await assert.rejects(legacy.getSecret('x', 'api_key'), /schema version/);
|
||||
|
||||
// Future version we don't understand.
|
||||
await writeFile(path, JSON.stringify({ version: 999, values: {} }), 'utf8');
|
||||
const future = createFileCredentialStore(dir);
|
||||
await assert.rejects(future.getSecret('x', 'api_key'), /schema version/);
|
||||
});
|
||||
});
|
||||
|
||||
test('leaves no temp file behind after a write', async () => {
|
||||
await withTempDir(async (dir) => {
|
||||
const store = createFileCredentialStore(dir);
|
||||
await store.setSecret('a', 'api_key', 'k');
|
||||
const entries = await readdir(dir);
|
||||
assert.deepEqual(entries, ['credentials.json']);
|
||||
});
|
||||
});
|
||||
|
||||
test('creates the file 0600 on POSIX', { skip: !isPosix }, async () => {
|
||||
await withTempDir(async (dir) => {
|
||||
const store = createFileCredentialStore(dir);
|
||||
await store.setSecret('a', 'api_key', 'k');
|
||||
const mode = (await stat(join(dir, 'credentials.json'))).mode & 0o777;
|
||||
assert.equal(mode, 0o600);
|
||||
});
|
||||
});
|
||||
|
||||
test('re-chmods a pre-existing world-readable file to 0600 on write', {
|
||||
skip: !isPosix,
|
||||
}, async () => {
|
||||
await withTempDir(async (dir) => {
|
||||
const path = join(dir, 'credentials.json');
|
||||
// A valid v1 file that was created with a loose mode.
|
||||
await writeFile(path, JSON.stringify({ version: CREDENTIAL_SCHEMA_VERSION, values: {} }), {
|
||||
encoding: 'utf8',
|
||||
mode: 0o644,
|
||||
});
|
||||
const store = createFileCredentialStore(dir);
|
||||
await store.setSecret('a', 'api_key', 'k');
|
||||
const mode = (await stat(path)).mode & 0o777;
|
||||
assert.equal(mode, 0o600);
|
||||
});
|
||||
});
|
||||
|
||||
test('hardens a pre-existing world-accessible workspace dir to 0700 on write', {
|
||||
skip: !isPosix,
|
||||
}, async () => {
|
||||
await withTempDir(async (dir) => {
|
||||
await chmod(dir, 0o777); // a loose dir that predates the hardening
|
||||
const store = createFileCredentialStore(dir);
|
||||
await store.setSecret('a', 'api_key', 'k');
|
||||
// ensureSecretDir re-chmods an existing dir (mkdir's mode only applies on
|
||||
// creation); the writer and the lock share it, so the lock can't leave
|
||||
// the dir loose either.
|
||||
assert.equal((await stat(dir)).mode & 0o777, 0o700);
|
||||
});
|
||||
});
|
||||
|
||||
test('serializes concurrent writes across slugs without clobbering', async () => {
|
||||
await withTempDir(async (dir) => {
|
||||
// With no in-instance queue, these contend directly on the file lock —
|
||||
// this proves the lock alone serializes a read-modify-write so no slug is
|
||||
// dropped. A handful is enough; more just adds lock-poll wall-clock.
|
||||
const store = createFileCredentialStore(dir);
|
||||
const count = 8;
|
||||
await Promise.all(
|
||||
Array.from({ length: count }, (_unused, i) =>
|
||||
store.setSecret(`conn-${i}`, 'api_key', `key-${i}`),
|
||||
),
|
||||
);
|
||||
for (let i = 0; i < count; i++) {
|
||||
assert.equal(await store.getSecret(`conn-${i}`, 'api_key'), `key-${i}`);
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
test('two independent store instances writing concurrently both survive (cross-process lock)', async () => {
|
||||
await withTempDir(async (dir) => {
|
||||
// Separate instances => separate in-instance queues; only the file
|
||||
// lock can stop a read-modify-write lost update between them.
|
||||
const a = createFileCredentialStore(dir);
|
||||
const b = createFileCredentialStore(dir);
|
||||
await Promise.all([
|
||||
a.setSecret('slug-a', 'api_key', 'AAA'),
|
||||
b.setSecret('slug-b', 'api_key', 'BBB'),
|
||||
]);
|
||||
|
||||
const reader = createFileCredentialStore(dir);
|
||||
assert.equal(await reader.getSecret('slug-a', 'api_key'), 'AAA');
|
||||
assert.equal(await reader.getSecret('slug-b', 'api_key'), 'BBB');
|
||||
});
|
||||
});
|
||||
|
||||
test('a held lock is waited on, never stolen (no lost update)', async () => {
|
||||
await withTempDir(async (dir) => {
|
||||
const path = join(dir, 'credentials.json');
|
||||
// Hold the lock as another process (or a crashed one) would: the lock is
|
||||
// the `${path}.lock` directory. The store must wait for it, never steal it.
|
||||
const lockPath = `${path}.lock`;
|
||||
await mkdir(lockPath);
|
||||
|
||||
const store = createFileCredentialStore(dir);
|
||||
let settled = false;
|
||||
const write = store.setSecret('a', 'api_key', 'V').then(() => {
|
||||
settled = true;
|
||||
});
|
||||
|
||||
// The lock is held, so the write is blocked before its critical section:
|
||||
// it must not steal the lock and must not have written the file yet.
|
||||
await assert.rejects(stat(path)); // file absent — proven blocked, not stolen
|
||||
assert.equal(settled, false);
|
||||
|
||||
await rm(lockPath, { recursive: true, force: true }); // release
|
||||
await write;
|
||||
assert.equal(await store.getSecret('a', 'api_key'), 'V'); // proceeds only once the lock frees
|
||||
});
|
||||
});
|
||||
|
||||
test('a never-released lock fails loud with the lock path and recovery hint', async () => {
|
||||
await withTempDir(async (dir) => {
|
||||
const path = join(dir, 'credentials.json');
|
||||
await mkdir(`${path}.lock`); // a crashed holder's lock that never releases
|
||||
// A small timeout drives the fail-loud path without the production wait.
|
||||
// The error must name the lock dir AND how to recover, so the guidance
|
||||
// can't silently regress.
|
||||
await assert.rejects(
|
||||
withCredentialFileLock(path, async () => 'unreachable', 60),
|
||||
(error: Error) =>
|
||||
error.message.includes(`${path}.lock`) &&
|
||||
/remove that directory and retry/.test(error.message),
|
||||
);
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
describe('FileCredentialStore compareAndSetSecret', () => {
|
||||
// Optional capability: exercise it through a guarded helper so a store that
|
||||
// does not expose CAS is a caller's own fallback problem, not a test crash.
|
||||
function cas(
|
||||
store: CredentialStore,
|
||||
slug: string,
|
||||
kind: CredentialKind,
|
||||
expected: string | null,
|
||||
value: string,
|
||||
): Promise<CredentialCasResult> {
|
||||
assert.ok(store.compareAndSetSecret, 'file store exposes the CAS capability');
|
||||
return store.compareAndSetSecret(slug, kind, expected, value);
|
||||
}
|
||||
|
||||
test('commits when the basis still matches, and the write persists', async () => {
|
||||
await withTempDir(async (dir) => {
|
||||
const store = createFileCredentialStore(dir);
|
||||
await store.setSecret('acct', 'oauth_token', 'tok-basis');
|
||||
|
||||
const result = await cas(store, 'acct', 'oauth_token', 'tok-basis', 'tok-next');
|
||||
assert.deepEqual(result, { committed: true });
|
||||
assert.equal(await store.getSecret('acct', 'oauth_token'), 'tok-next');
|
||||
});
|
||||
});
|
||||
|
||||
test('commits a write-if-absent (expected null) only while the entry is absent', async () => {
|
||||
await withTempDir(async (dir) => {
|
||||
// Decide "store has no token" and write in one serialized step. A value
|
||||
// written between the check and the write must make this writer lose.
|
||||
const importer = createFileCredentialStore(dir);
|
||||
const other = createFileCredentialStore(dir);
|
||||
|
||||
// Someone writes a token after the importer would have read "absent".
|
||||
await other.setSecret('acct', 'oauth_token', 'tok-live');
|
||||
|
||||
const blocked = await cas(importer, 'acct', 'oauth_token', null, 'tok-import');
|
||||
assert.deepEqual(blocked, { committed: false, current: 'tok-live' });
|
||||
assert.equal(await other.getSecret('acct', 'oauth_token'), 'tok-live');
|
||||
|
||||
// With a genuinely absent entry the same write-if-absent commits.
|
||||
const committed = await cas(importer, 'other-acct', 'oauth_token', null, 'tok-import');
|
||||
assert.deepEqual(committed, { committed: true });
|
||||
assert.equal(await importer.getSecret('other-acct', 'oauth_token'), 'tok-import');
|
||||
});
|
||||
});
|
||||
|
||||
test('two store instances racing on the same basis: loser sees the entry changed and adopts it', async () => {
|
||||
await withTempDir(async (dir) => {
|
||||
// Two separate instances share the file (a cross-process refresh). Both
|
||||
// read the same basis; only the file lock decides the winner.
|
||||
const a = createFileCredentialStore(dir);
|
||||
const b = createFileCredentialStore(dir);
|
||||
await a.setSecret('acct', 'oauth_token', 'tok-basis');
|
||||
|
||||
// A commits first, then B tries with the now-stale basis.
|
||||
const winner = await cas(a, 'acct', 'oauth_token', 'tok-basis', 'tok-A');
|
||||
const loser = await cas(b, 'acct', 'oauth_token', 'tok-basis', 'tok-B');
|
||||
|
||||
assert.deepEqual(winner, { committed: true });
|
||||
// Entry changed (not gone): current is a string the loser adopts.
|
||||
assert.deepEqual(loser, { committed: false, current: 'tok-A' });
|
||||
const reader = createFileCredentialStore(dir);
|
||||
assert.equal(await reader.getSecret('acct', 'oauth_token'), 'tok-A');
|
||||
});
|
||||
});
|
||||
|
||||
test('a basis whose entry was deleted (logout) is distinguishable from a changed one', async () => {
|
||||
await withTempDir(async (dir) => {
|
||||
const a = createFileCredentialStore(dir);
|
||||
const b = createFileCredentialStore(dir);
|
||||
await a.setSecret('acct', 'oauth_token', 'tok-basis');
|
||||
|
||||
// A terminal logout removes the entry after B read its basis.
|
||||
await a.deleteSecret('acct', 'oauth_token');
|
||||
|
||||
const result = await cas(b, 'acct', 'oauth_token', 'tok-basis', 'tok-resurrect');
|
||||
// Entry gone (current === null): the caller must NOT resurrect it, and the
|
||||
// write did not commit.
|
||||
assert.deepEqual(result, { committed: false, current: null });
|
||||
const reader = createFileCredentialStore(dir);
|
||||
assert.equal(await reader.getSecret('acct', 'oauth_token'), null);
|
||||
});
|
||||
});
|
||||
|
||||
test('concurrent CAS from the same basis: exactly one wins, the loser returns the winner value', async () => {
|
||||
await withTempDir(async (dir) => {
|
||||
const a = createFileCredentialStore(dir);
|
||||
const b = createFileCredentialStore(dir);
|
||||
await a.setSecret('acct', 'oauth_token', 'tok-basis');
|
||||
|
||||
const [ra, rb] = await Promise.all([
|
||||
cas(a, 'acct', 'oauth_token', 'tok-basis', 'tok-A'),
|
||||
cas(b, 'acct', 'oauth_token', 'tok-basis', 'tok-B'),
|
||||
]);
|
||||
|
||||
const winners = [ra, rb].filter((r) => r.committed);
|
||||
assert.equal(winners.length, 1, 'exactly one CAS commits');
|
||||
const winnerValue = ra.committed ? 'tok-A' : 'tok-B';
|
||||
const loser = ra.committed ? rb : ra;
|
||||
assert.deepEqual(loser, { committed: false, current: winnerValue });
|
||||
|
||||
const reader = createFileCredentialStore(dir);
|
||||
assert.equal(await reader.getSecret('acct', 'oauth_token'), winnerValue);
|
||||
});
|
||||
});
|
||||
});
|
||||
Reference in new issue
Block a user