expandai 0.0.2 → 0.0.3

package/src/Commands/Status.ts

@@ -0,0 +1,228 @@
+import { Command, Options, Prompt } from '@effect/cli'
+import { Terminal } from '@effect/platform'
+import { Console, Effect, Either, Logger, LogLevel, Option, Schema } from 'effect'
+import { InitErrorEnvelope, InitHarness, InitScope } from '../Init/Domain.js'
+import { StatusRequest, StatusResult, StatusService, StatusServiceError } from '../Init/Status.js'
+import { type OnboardingExecutionModeInput, resolveOnboardingExecutionMode } from './Init.js'
+
+const harness = Options.text('harness').pipe(Options.optional, Options.withDescription('Agent harness to inspect'))
+const scope = Options.text('scope').pipe(Options.optional, Options.withDescription('Configuration scope'))
+const json = Options.boolean('json').pipe(Options.withDescription('Emit one machine-readable JSON result'))
+const config = { harness, scope, json }
+
+const ErrorJson = Schema.parseJson(InitErrorEnvelope)
+const StatusResultJson = Schema.parseJson(StatusResult)
+const INVALID_ARGUMENTS_MESSAGE =
+	'Agent status requires --harness claude-code|cursor|opencode|codex, --scope project|global, and --json.'
+
+function errorJson(code: string, message: string, recoverable: boolean): string {
+	return Schema.encodeSync(ErrorJson)(
+		new InitErrorEnvelope({ schemaVersion: 1, status: 'error', code, message, recoverable }),
+	)
+}
+
+function invalidArgumentsJson(): string {
+	return errorJson('invalid_arguments', INVALID_ARGUMENTS_MESSAGE, true)
+}
+
+function emitError(code: string, message: string, recoverable: boolean, exitCode: number) {
+	return Console.error(errorJson(code, message, recoverable)).pipe(
+		Effect.zipRight(Effect.sync(() => void (process.exitCode = exitCode))),
+	)
+}
+
+export interface StatusCommandOptions {
+	readonly harness: Option.Option<string>
+	readonly json: boolean
+	readonly scope: Option.Option<string>
+}
+
+/** Selects the status surface using the same machine-safety precedence as init. */
+export function resolveStatusExecutionMode(input: OnboardingExecutionModeInput): 'human' | 'machine' | undefined {
+	return resolveOnboardingExecutionMode(input, 'status')
+}
+
+function parseMachineArguments(args: readonly string[]): StatusCommandOptions | undefined {
+	function parse(index: number, parsed: StatusCommandOptions): StatusCommandOptions | undefined {
+		if (index >= args.length) return parsed
+		const token = args[index]
+		if (token === '--json' && !parsed.json) return parse(index + 1, { ...parsed, json: true })
+		if (token !== '--harness' && token !== '--scope') return undefined
+		const value = args[index + 1]
+		if (value === undefined || value.startsWith('-')) return undefined
+		if (token === '--harness' && Option.isNone(parsed.harness)) {
+			return parse(index + 2, { ...parsed, harness: Option.some(value) })
+		}
+		if (token === '--scope' && Option.isNone(parsed.scope)) {
+			return parse(index + 2, { ...parsed, scope: Option.some(value) })
+		}
+		return undefined
+	}
+
+	return parse(0, { harness: Option.none(), json: false, scope: Option.none() })
+}
+
+/** Returns safe JSON before Effect CLI can render parser help or acquire services. */
+export function preflightAgentStatusArgv(argv: readonly string[]): string | undefined {
+	if (argv[2] !== 'status') return undefined
+	const args = argv.slice(3)
+	if (args.length === 1 && (args[0] === '--help' || args[0] === '-h')) return undefined
+	const parsed = parseMachineArguments(args)
+	if (parsed === undefined || !parsed.json) return invalidArgumentsJson()
+	if (Option.isNone(Option.flatMap(parsed.harness, (value) => Schema.decodeUnknownOption(InitHarness)(value)))) {
+		return invalidArgumentsJson()
+	}
+	if (!Option.contains(parsed.scope, 'project') && !Option.contains(parsed.scope, 'global')) {
+		return invalidArgumentsJson()
+	}
+	return undefined
+}
+
+const HARNESS_LABELS: Record<typeof InitHarness.Type, string> = {
+	'claude-code': 'Claude Code',
+	cursor: 'Cursor',
+	codex: 'Codex',
+	opencode: 'OpenCode',
+}
+
+/** Only these install a web-fetch hook; the line is meaningless for the rest. */
+const HOOK_HARNESSES: ReadonlyArray<typeof InitHarness.Type> = ['claude-code', 'opencode']
+
+function renderHumanStatus(result: StatusResult): string {
+	const pending = result.pendingAuthorization.count === 1 ? 'approval pending' : 'none'
+	const installation = result.installation.configured ? 'configured' : 'partial or not configured'
+	const configured = (present: boolean) => (present ? 'configured' : 'not configured')
+	// `result.harness` was never read: every harness printed as "Claude Code", and
+	// a correctly configured Cursor machine also reported a missing WebFetch hook
+	// it never installs. The guide sends users here to confirm setup, so this was
+	// the last thing they saw.
+	return [
+		'Expand status',
+		`Auth: ${result.auth.state}`,
+		`Pending authorization: ${pending}`,
+		`${HARNESS_LABELS[result.harness]}: ${installation}`,
+		...(HOOK_HARNESSES.includes(result.harness)
+			? [`WebFetch hook: ${configured(result.installation.components.webfetchHook)}`]
+			: []),
+		`Runtime skill: ${configured(result.installation.components.runtimeSkill)}`,
+		`MCP: ${configured(result.installation.components.mcp)}`,
+		`Runtime: ${result.installation.runtimeState}`,
+	].join('\n')
+}
+
+const runStatusService = Effect.fnUntraced(function* (request: StatusRequest, jsonOutput: boolean) {
+	const service = yield* StatusService
+	// Log suppression belongs here, not in the service, and only for machine
+	// output: `--json` writes its result *and* its structured error envelope to
+	// stderr, so a warning interleaved there breaks the one-object contract an
+	// agent parses. Human status keeps its diagnostics — it is the command
+	// someone runs when something is already wrong.
+	const result = yield* Effect.either(
+		jsonOutput ? service.run(request).pipe(Logger.withMinimumLogLevel(LogLevel.None)) : service.run(request),
+	)
+	if (Either.isLeft(result)) {
+		const error = result.left
+		if (error instanceof StatusServiceError) {
+			yield* emitError(error.code, error.message, error.recoverable, 1)
+			return
+		}
+		yield* emitError('status_failed', 'Expand status could not be inspected safely.', true, 1)
+		return
+	}
+	if (!jsonOutput) {
+		yield* Console.log(renderHumanStatus(result.right))
+		return
+	}
+	const encoded = yield* Schema.encode(StatusResultJson)(result.right).pipe(
+		Effect.catchAll(() =>
+			emitError('invalid_status_result', 'Expand status returned an invalid result.', false, 1).pipe(
+				Effect.as(undefined),
+			),
+		),
+	)
+	if (typeof encoded === 'string') yield* Console.log(encoded)
+})
+
+const runMachineStatus = Effect.fnUntraced(function* ({ harness, json, scope }: StatusCommandOptions) {
+	if (
+		!json ||
+		Option.isNone(Option.flatMap(harness, (value) => Schema.decodeUnknownOption(InitHarness)(value))) ||
+		(!Option.contains(scope, 'project') && !Option.contains(scope, 'global'))
+	) {
+		yield* emitError('invalid_arguments', INVALID_ARGUMENTS_MESSAGE, true, 2)
+		return
+	}
+	const request = yield* Schema.decodeUnknown(StatusRequest)({
+		harness: Option.getOrUndefined(harness),
+		scope: Option.getOrUndefined(scope),
+	}).pipe(
+		Effect.catchAll(() =>
+			emitError('invalid_arguments', INVALID_ARGUMENTS_MESSAGE, true, 2).pipe(Effect.as(undefined)),
+		),
+	)
+	if (request !== undefined) yield* runStatusService(request, true)
+})
+
+export class StatusTerminalInteraction extends Effect.Service<StatusTerminalInteraction>()(
+	'@expandai/cli/Commands/StatusTerminalInteraction',
+	{
+		effect: Effect.gen(function* () {
+			const terminal = yield* Terminal.Terminal
+			const chooseHarness = Effect.fnUntraced(function* () {
+				return yield* Prompt.select({
+					message: 'Which agent harness should Expand inspect?',
+					// init configures all four, so inspection must cover all four.
+					choices: [
+						{ title: 'Claude Code', value: 'claude-code' as const },
+						{ title: 'Cursor', value: 'cursor' as const },
+						{ title: 'opencode', value: 'opencode' as const },
+						{ title: 'Codex', value: 'codex' as const },
+					],
+				}).pipe(Effect.provideService(Terminal.Terminal, terminal))
+			})
+			const chooseScope = Effect.fnUntraced(function* () {
+				return yield* Prompt.select({
+					message: 'Which configuration scope should Expand inspect?',
+					choices: [
+						{ title: 'This project', value: 'project' as const },
+						{ title: 'All projects for this user', value: 'global' as const },
+					],
+				}).pipe(Effect.provideService(Terminal.Terminal, terminal))
+			})
+			return { chooseHarness, chooseScope } as const
+		}),
+	},
+) {}
+
+export const runHumanStatus = Effect.fnUntraced(function* (options: StatusCommandOptions) {
+	if (options.json) {
+		yield* runMachineStatus(options)
+		return
+	}
+	const interaction = yield* StatusTerminalInteraction
+	const harnessInput = Option.isSome(options.harness) ? options.harness.value : yield* interaction.chooseHarness()
+	const scopeInput = Option.isSome(options.scope) ? options.scope.value : yield* interaction.chooseScope()
+	const decodedHarness = Schema.decodeUnknownOption(InitHarness)(harnessInput)
+	const decodedScope = Schema.decodeUnknownOption(InitScope)(scopeInput)
+	if (Option.isNone(decodedHarness) || Option.isNone(decodedScope)) {
+		yield* emitError('invalid_arguments', INVALID_ARGUMENTS_MESSAGE, true, 2)
+		return
+	}
+	const request = new StatusRequest({
+		harness: decodedHarness.value,
+		scope: decodedScope.value,
+	})
+	yield* runStatusService(request, false)
+})
+
+const description = 'Inspect redacted local Expand onboarding status'
+
+export const HumanStatusCommand = Command.make('status', config).pipe(
+	Command.withDescription(description),
+	Command.withHandler(runHumanStatus),
+)
+
+export const AgentStatusCommand = Command.make('status', config).pipe(
+	Command.withDescription(description),
+	Command.withHandler(runMachineStatus),
+)

package/src/Commands/Telemetry.ts

@@ -0,0 +1,42 @@
+import { Command } from '@effect/cli'
+import { Console, Effect } from 'effect'
+import { ConfigManager } from '../Config.js'
+import { Telemetry } from '../Telemetry.js'
+
+const setEnabled = Effect.fnUntraced(function* (enabled: boolean) {
+	const configManager = yield* ConfigManager
+	const { config } = yield* configManager.readConfigFile()
+	// updateConfig fails with ConfigParseError on an undecodable file — surfaced
+	// to the user rather than overwriting whatever the file held.
+	yield* configManager.updateConfig({ telemetry: { ...config.telemetry, enabled } })
+	yield* Console.log(`Telemetry ${enabled ? 'enabled' : 'disabled'}.`)
+})
+
+const showStatus = Effect.fnUntraced(function* () {
+	const telemetry = yield* Telemetry
+	yield* Console.log(
+		telemetry.enabled
+			? 'Telemetry is enabled. Disable with `expandai telemetry disable` or EXPANDAI_NO_TELEMETRY=1.'
+			: 'Telemetry is disabled.',
+	)
+})
+
+const StatusCommand = Command.make('status').pipe(
+	Command.withDescription('Show whether anonymous usage telemetry is enabled'),
+	Command.withHandler(() => showStatus()),
+)
+
+const EnableCommand = Command.make('enable').pipe(
+	Command.withDescription('Enable anonymous usage telemetry'),
+	Command.withHandler(() => setEnabled(true)),
+)
+
+const DisableCommand = Command.make('disable').pipe(
+	Command.withDescription('Disable anonymous usage telemetry'),
+	Command.withHandler(() => setEnabled(false)),
+)
+
+export const TelemetryCommand = Command.make('telemetry').pipe(
+	Command.withDescription('Manage anonymous usage telemetry'),
+	Command.withSubcommands([StatusCommand, EnableCommand, DisableCommand]),
+)