@skrr-ai/cli 0.1.94 → 0.1.95

package/dist/lib/managed-instruction-setup.js

@@ -0,0 +1,306 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shouldSkipInstructionPrompt = shouldSkipInstructionPrompt;
+exports.instructionProviderLabel = instructionProviderLabel;
+exports.runManagedInstructionSetup = runManagedInstructionSetup;
+exports.maybeOfferManagedInstructionSetup = maybeOfferManagedInstructionSetup;
+const node_crypto_1 = require("node:crypto");
+const auth_core_1 = require("@skrr-ai/auth-core");
+const data_provider_1 = require("@skrr-ai/data-provider");
+const harness_provider_input_1 = require("./harness-provider-input");
+const managed_instruction_local_1 = require("./managed-instruction-local");
+const prompt_1 = require("./prompt");
+const TEMPLATE_KEY = 'oversky-task-management';
+function shouldSkipInstructionPrompt() {
+    return Boolean(!process.stdin.isTTY ||
+        !process.stdout.isTTY ||
+        process.env.CI ||
+        process.env.OVERSKY_HEADLESS ||
+        process.env.OVERSKY_SESSION_TASK_ID ||
+        process.env.OVERSKY_SESSION_AGENT_ID ||
+        process.env.OVERSKY_AGENT_ID ||
+        process.env.OVERSKY_DISABLE_INSTRUCTION_OFFER === '1');
+}
+function instructionProviderLabel(provider) {
+    if (provider === 'claude')
+        return 'Claude Code';
+    if (provider === 'codex')
+        return 'Codex';
+    return auth_core_1.FIRST_PARTY_HARNESS.displayName;
+}
+function detectedProviders(daemon) {
+    let capabilities = [];
+    if (Array.isArray(daemon.capabilities))
+        capabilities = daemon.capabilities.map(String);
+    else if (typeof daemon.capabilities === 'string') {
+        try {
+            const parsed = JSON.parse(daemon.capabilities);
+            if (Array.isArray(parsed))
+                capabilities = parsed.map(String);
+        }
+        catch {
+            capabilities = daemon.capabilities.split(',').map((entry) => entry.trim());
+        }
+    }
+    const providers = [];
+    if (capabilities.includes('claude_session'))
+        providers.push('claude');
+    if (capabilities.includes('codex_session'))
+        providers.push('codex');
+    if (capabilities.some(auth_core_1.isFirstPartyHarnessCapability))
+        providers.push(auth_core_1.FIRST_PARTY_HARNESS.provider);
+    return providers;
+}
+function eligibleProviders(offer, detected) {
+    // Preserve suppression on older servers without provider-scoped decisions.
+    const providerOffers = offer.providerOffers;
+    if (providerOffers) {
+        return detected.filter((provider) => providerOffers.some((entry) => entry.provider === provider && entry.eligible));
+    }
+    return offer.eligible ? detected : [];
+}
+function printStatus(offer, options) {
+    for (const target of offer.targets ?? []) {
+        if (target.desiredState !== 'installed')
+            continue;
+        if (options.trigger !== 'manual' && target.status !== 'error')
+            continue;
+        const policy = target.trackingMode === 'pinned' ? 'fixed version' : 'automatic updates';
+        options.log(`${instructionProviderLabel(target.provider)}: ${target.status}, ${policy}${target.appliedPath ? ` — ${target.appliedPath}` : ''}.`);
+        if (target.status === 'error') {
+            options.log(`  ${target.lastError || 'The daemon could not apply this instruction.'} Check \`skrr instructions status\`.`);
+        }
+        else if (options.trigger === 'manual' && target.status !== 'synced') {
+            options.log('  Awaiting daemon confirmation; `skrr instructions status` shows the applied file and version.');
+        }
+    }
+    if (offer.bundleId && options.trigger === 'manual') {
+        options.log(`\`skrr instructions show ${offer.bundleId}\` shows saved versions and pending template updates.`);
+    }
+}
+/** Read-only preflight precedes every consent and every write to the API. */
+async function runManagedInstructionSetup(options) {
+    const result = {
+        status: 'skipped',
+        targets: [],
+        installed: [],
+        decisions: [],
+    };
+    const interactive = !shouldSkipInstructionPrompt() && !options.json;
+    if (options.trigger !== 'manual' && !interactive)
+        return result;
+    if (!interactive && !options.yes && !options.review) {
+        throw new Error('Instruction setup needs a terminal, or --yes --provider <provider> --update-policy <latest|pinned>. Use --review --json to inspect without installing.');
+    }
+    if (options.yes && (!options.providers?.length || !options.trackingMode)) {
+        throw new Error('--yes requires explicit --provider and --update-policy; no installation was authorized.');
+    }
+    const daemonId = options.daemonId ??
+        (await (0, managed_instruction_local_1.resolveLocalInstructionDaemon)({
+            waitMs: options.waitForLocalReady ? 20_000 : 0,
+            log: options.log,
+        }));
+    if (!daemonId) {
+        result.status = 'unavailable';
+        result.message =
+            'Could not verify a signed-in local daemon for this account, server, and profile. Run `skrr daemon status`, then `skrr instructions setup`; use --daemon <id> to choose a machine explicitly.';
+        if (options.trigger === 'manual')
+            options.log(result.message);
+        return result;
+    }
+    result.daemonId = daemonId;
+    const [daemons, response] = await Promise.all([
+        data_provider_1.dataService.getDaemons(),
+        data_provider_1.dataService.getManagedInstructionOffer(TEMPLATE_KEY),
+    ]);
+    const daemon = daemons.active.find((entry) => entry.daemonId === daemonId);
+    const offer = response.offers.find((entry) => entry.daemonId === daemonId);
+    if (!daemon || !offer) {
+        result.status = 'unavailable';
+        result.message =
+            'The selected daemon is not connected or does not support instruction setup. Check `skrr daemon status` or `skrr list-daemons` and retry.';
+        if (options.trigger === 'manual')
+            options.log(result.message);
+        return result;
+    }
+    result.targets = offer.targets ?? [];
+    if (!options.json) {
+        printStatus(offer, options);
+        if (options.trigger === 'manual' &&
+            response.preset.pendingTemplateVersionId &&
+            response.preset.bundleId) {
+            options.log(`Built-in template v${response.preset.pendingTemplateVersion} is available for your customized instruction. Review with \`skrr instructions diff ${response.preset.bundleId} --from ${response.preset.contentVersion} --to ${response.preset.pendingTemplateVersionId}\`.`);
+            options.log(`After reviewing, \`skrr instructions activate ${response.preset.bundleId} --version ${response.preset.pendingTemplateVersionId}\` updates all targets tracking the current version; fixed versions stay pinned.`);
+        }
+        if (options.trigger === 'manual')
+            for (const target of result.targets) {
+                if (target.trackingMode === 'pinned' &&
+                    target.desiredState === 'installed' &&
+                    target.appliedVersionNumber &&
+                    target.appliedVersionNumber < response.preset.contentVersion) {
+                    options.log(`${instructionProviderLabel(target.provider)} stays on fixed v${target.appliedVersionNumber}; v${response.preset.contentVersion} is current. Review with \`skrr instructions setup --provider ${target.provider} --review\`, then rerun with --update-policy pinned to adopt it.`);
+                }
+            }
+    }
+    const detected = detectedProviders(daemon);
+    const providers = options.providers?.length
+        ? (0, harness_provider_input_1.canonicalHarnessInputs)(options.providers)
+        : options.review
+            ? detected
+            : eligibleProviders(offer, detected);
+    if (!providers.length) {
+        result.status = 'unchanged';
+        if (options.trigger === 'manual' && !options.json) {
+            options.log('No new providers need setup. To change a previous decision or update policy, pass --provider <provider>.');
+        }
+        return result;
+    }
+    if (providers.some((provider) => !detected.includes(provider))) {
+        throw new Error('The selected machine has not detected every requested provider. Install the coding agent first and retry; no instruction targets were created.');
+    }
+    const prepared = await data_provider_1.dataService.prepareManagedInstructionOffer(TEMPLATE_KEY, {
+        daemonId,
+        providers,
+    });
+    result.prepared = prepared;
+    if (prepared.daemonId !== daemonId)
+        throw new Error('Instruction preflight returned another machine; no installation was authorized.');
+    if (prepared.readiness !== 'ready') {
+        result.status = 'unavailable';
+        result.message =
+            prepared.message ||
+                'The daemon cannot preflight these files yet. Update or reconnect it and run `skrr instructions setup`.';
+        if (!options.json)
+            options.log(result.message);
+        return result;
+    }
+    const preflight = new Map(prepared.providers.map((entry) => [entry.provider, entry]));
+    const previews = new Map(prepared.previews.map((entry) => [entry.provider, entry]));
+    for (const provider of providers) {
+        const placement = preflight.get(provider);
+        const preview = previews.get(provider);
+        if (!placement?.instructionPath ||
+            !preview ||
+            (0, node_crypto_1.createHash)('sha256').update(preview.body).digest('hex') !== preview.hash) {
+            throw new Error(`The daemon did not return a verified path and exact preview for ${instructionProviderLabel(provider)}; no installation was authorized.`);
+        }
+    }
+    if (!options.json) {
+        options.log('');
+        options.log(`Managed instructions on ${daemon.deviceName || daemonId} (${daemonId})`);
+        options.log('Global scope: these removable blocks apply to future coding-agent sessions across all projects. skrr maintains its block and preserves your other file content.');
+        for (const provider of providers) {
+            const placement = preflight.get(provider);
+            options.log(`${instructionProviderLabel(provider)}: ${placement.instructionPath} (${placement.loadingStatus})`);
+            options.log(`  Reviewed content SHA-256: ${previews.get(provider).hash}`);
+            for (const issue of placement.issues)
+                options.log(`  ${issue.severity}: ${issue.message}`);
+        }
+    }
+    if (options.review) {
+        result.status = 'reviewed';
+        if (!options.json)
+            for (const provider of providers)
+                printPreview(provider, previews.get(provider), options.log);
+        return result;
+    }
+    // Validate all automated placements before creating any target.
+    if (options.yes)
+        for (const provider of providers) {
+            const placement = preflight.get(provider);
+            if (!placement.canInstall || placement.loadingStatus === 'shadowed') {
+                throw new Error(`Cannot install ${instructionProviderLabel(provider)}: ${placement.issues.map((issue) => issue.message).join(' ') || placement.loadingStatus}. Resolve this and retry; no targets were created.`);
+            }
+        }
+    const install = [];
+    for (const provider of providers) {
+        const placement = preflight.get(provider);
+        if (!placement.canInstall || placement.loadingStatus === 'shadowed')
+            continue;
+        let answer = options.yes ? 'y' : '';
+        const alreadyAccepted = offer.providerOffers?.some((entry) => entry.provider === provider && entry.selected) ||
+            offer.targets?.some((target) => target.provider === provider);
+        if (!options.yes) {
+            options.log(alreadyAccepted
+                ? 'y: update installation policy, v: exact preview, n/Enter: keep the current decision'
+                : 'y: install, v: exact preview, n/Enter: not now, d: do not ask for this provider');
+            answer = (await (0, prompt_1.prompt)(`Set up ${instructionProviderLabel(provider)}? ${alreadyAccepted ? '[y/N/v]' : '[y/N/v/d]'} `)).toLowerCase();
+            while (answer === 'v' || answer === 'view') {
+                printPreview(provider, previews.get(provider), options.log);
+                answer = (await (0, prompt_1.prompt)(`Set up ${instructionProviderLabel(provider)}? ${alreadyAccepted ? '[y/N]' : '[y/N/d]'} `)).toLowerCase();
+            }
+        }
+        const action = answer === 'y' || answer === 'yes'
+            ? 'install'
+            : alreadyAccepted
+                ? 'keep'
+                : answer === 'd' || answer === 'decline'
+                    ? 'decline'
+                    : 'snooze';
+        result.decisions.push({ provider, action });
+        if (action === 'install')
+            install.push(provider);
+    }
+    let trackingMode = options.trackingMode;
+    if (install.length && !trackingMode) {
+        options.log('Automatic updates follow the current saved instruction. Fixed version keeps today’s content; dynamic account identity can still refresh.');
+        const answer = (await (0, prompt_1.prompt)('Update policy: automatic [a] or fixed current version [p]? [a/p] ')).toLowerCase();
+        if (answer && !['a', 'auto', 'automatic', 'p', 'pin', 'pinned'].includes(answer)) {
+            throw new Error('Unknown update policy; no installation was authorized. Run `skrr instructions setup` again.');
+        }
+        trackingMode = ['p', 'pin', 'pinned'].includes(answer) ? 'pinned' : 'latest';
+    }
+    if (install.length) {
+        const accepted = await data_provider_1.dataService.acceptManagedInstructionOffer(TEMPLATE_KEY, {
+            daemonId,
+            providers: install,
+            trackingMode,
+            expectedHash: prepared.preset.hash,
+            expectedContentVersion: prepared.preset.contentVersion,
+            expectedRenderedHashes: Object.fromEntries(install.map((provider) => [provider, previews.get(provider).hash])),
+        });
+        result.installed = accepted.targets;
+        if (!options.json) {
+            options.log(`Installation queued for ${install.map(instructionProviderLabel).join(', ')} (${trackingMode === 'latest' ? 'automatic updates' : 'fixed current version'}).`);
+            options.log('`skrr instructions status` confirms the applied path and version. Edits inside the managed block are maintained by skrr; use `skrr instructions update` to customize the saved instruction.');
+        }
+    }
+    for (const action of ['snooze', 'decline']) {
+        const declined = result.decisions
+            .filter((entry) => entry.action === action)
+            .map((entry) => entry.provider);
+        if (!declined.length)
+            continue;
+        await data_provider_1.dataService.respondManagedInstructionOffer(TEMPLATE_KEY, {
+            daemonId,
+            providers: declined,
+            action,
+        });
+        if (!options.json)
+            options.log(`${declined.map(instructionProviderLabel).join(', ')}: ${action === 'snooze' ? 'not now; reminders paused for 14 days' : 'will not ask again'}. Revisit with \`skrr instructions setup --provider ${declined[0]}\`.`);
+    }
+    result.status = result.decisions.some((entry) => entry.action !== 'keep')
+        ? 'decided'
+        : 'unchanged';
+    return result;
+}
+function printPreview(provider, preview, log) {
+    log(`Exact ${instructionProviderLabel(provider)} managed instruction (SHA-256 ${preview.hash}):`);
+    log('---');
+    log(preview.body);
+    log('---');
+}
+/** Optional onboarding must not change the successful login/task exit status. */
+async function maybeOfferManagedInstructionSetup(options) {
+    if (shouldSkipInstructionPrompt())
+        return;
+    try {
+        const result = await runManagedInstructionSetup(options);
+        if (options.trigger === 'login' && result.status === 'unavailable' && result.message)
+            options.log(result.message);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        options.log(`Managed instruction setup could not finish: ${message}. Run \`skrr instructions setup\` when ready.`);
+    }
+}

package/dist/lib/memory-sync.d.ts

@@ -1,6 +1,7 @@
 export declare const MEMORY_SYNC_MANIFEST = ".memory-sync";
 export declare const MEMORY_SYNC_BASIS = ".memory-sync-basis";
 export declare const MEMORY_SYNC_CONFLICTS = ".memory-conflicts";
+export declare const MEMORY_SYNC_QUARANTINE = ".memory-quarantine";
 export declare const MEMORY_SYNC_TOMBSTONES = ".memory-tombstones";
 export interface RemoteMemoryEntry {
     memoryId: string;