dikasta 0.3.31__py3-none-any.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- account_export_command.py +55 -0
- active_command.py +61 -0
- attachments.py +488 -0
- attention.py +57 -0
- bug_bundle.py +324 -0
- challenge_command.py +102 -0
- change_graph.py +1162 -0
- changed_coverage.py +229 -0
- ci_failure.py +180 -0
- codemod.py +490 -0
- codemod_rename.py +971 -0
- command_counts.py +43 -0
- command_help.py +283 -0
- commit_style.py +92 -0
- daily_digest.py +179 -0
- diff_view.py +129 -0
- dikasta-0.3.31.dist-info/METADATA +81 -0
- dikasta-0.3.31.dist-info/RECORD +132 -0
- dikasta-0.3.31.dist-info/WHEEL +5 -0
- dikasta-0.3.31.dist-info/entry_points.txt +3 -0
- dikasta-0.3.31.dist-info/licenses/LICENSE +202 -0
- dikasta-0.3.31.dist-info/top_level.txt +99 -0
- dikasta.py +7818 -0
- dikasta_api.py +135 -0
- environment_view.py +47 -0
- error_text.py +130 -0
- evidence_bundle.py +123 -0
- explain_command.py +76 -0
- file_links.py +56 -0
- first_week.py +70 -0
- fix_command.py +88 -0
- follow_command.py +66 -0
- git_notes.py +109 -0
- host_client.py +417 -0
- inline_images.py +82 -0
- issue_groups.py +362 -0
- jury_view.py +346 -0
- known_issues.py +85 -0
- last_failure.py +135 -0
- local_state.py +354 -0
- machine_blame.py +97 -0
- markdown_render.py +384 -0
- memories_view.py +127 -0
- migration_trial_command.py +43 -0
- mutation.py +228 -0
- native_changes.py +473 -0
- native_context.py +846 -0
- native_delivery.py +1062 -0
- native_export.py +286 -0
- native_extensions.py +190 -0
- native_headless.py +268 -0
- native_lessons.py +222 -0
- native_playbooks.py +64 -0
- native_service_commands.py +343 -0
- native_services.py +649 -0
- native_session.py +1798 -0
- native_skills.py +312 -0
- native_templates.py +172 -0
- native_why.py +86 -0
- native_workspace.py +1246 -0
- next_steps.py +43 -0
- onboarding.py +887 -0
- open_schemas.py +260 -0
- plan_impact_view.py +21 -0
- playbook_export.py +40 -0
- prepush.py +262 -0
- private_files.py +62 -0
- prose_style.py +320 -0
- protected_paths.py +157 -0
- published_config.py +101 -0
- question_cards.py +95 -0
- queue_store.py +111 -0
- release_notes.py +172 -0
- reply_evidence.py +78 -0
- repro_command.py +176 -0
- retired_models.py +40 -0
- review_hook.py +144 -0
- route_view.py +128 -0
- run_command.py +193 -0
- sample_project.py +123 -0
- scenario_draft_command.py +29 -0
- sentence_trace.py +97 -0
- server/shared/__init__.py +6 -0
- server/shared/artifact_evidence.py +1328 -0
- server/shared/atomic_files.py +114 -0
- server/shared/browser_evidence.py +345 -0
- server/shared/cited_diagrams.py +740 -0
- server/shared/client_versions.py +16 -0
- server/shared/code_audits.py +1074 -0
- server/shared/dead_code.py +124 -0
- server/shared/delivery_intent.py +54 -0
- server/shared/dependency_evidence.py +2227 -0
- server/shared/dependency_formats.py +516 -0
- server/shared/dependency_meaning.py +1125 -0
- server/shared/history_evidence.py +218 -0
- server/shared/history_inquiry.py +715 -0
- server/shared/house_style.py +143 -0
- server/shared/http_redirects.py +20 -0
- server/shared/image_attachments.py +428 -0
- server/shared/infra_evidence.py +941 -0
- server/shared/irreversible.py +44 -0
- server/shared/native_index.py +558 -0
- server/shared/payload_codec.py +119 -0
- server/shared/plan_diff.py +82 -0
- server/shared/plan_impact.py +175 -0
- server/shared/ticket_rubric.py +759 -0
- server/shared/version_ranges.py +310 -0
- server/shared/workspace_protocol.py +287 -0
- server/shared/yaml_reader.py +726 -0
- server/shared/zero_tier.py +165 -0
- shell_completion.py +73 -0
- shipping.py +422 -0
- spec_drift.py +205 -0
- spike_command.py +83 -0
- split_apply.py +455 -0
- syntax_colour.py +93 -0
- task_worktree.py +134 -0
- team_share.py +244 -0
- telemetry_view.py +66 -0
- terminal_comfort.py +482 -0
- terminal_signals.py +210 -0
- terminal_ui.py +1896 -0
- terminal_views.py +245 -0
- tidy_command.py +113 -0
- timeline.py +257 -0
- token_store.py +614 -0
- tree_view.py +160 -0
- upgrade_command.py +142 -0
- voice_input.py +62 -0
- watch_mode.py +122 -0
- weekly_view.py +29 -0
- whats_new.py +153 -0
|
@@ -0,0 +1,55 @@
|
|
|
1
|
+
"""`dikasta export-account [EMAIL]`: one person's data in one JSON file (engine account_export.py).
|
|
2
|
+
|
|
3
|
+
Your own account by default; an administrator may name another by email. The file is new
|
|
4
|
+
(never overwritten) and readable by you alone, because it holds the person's conversations.
|
|
5
|
+
Deleting stays `dikasta admin delete-user`.
|
|
6
|
+
"""
|
|
7
|
+
import json
|
|
8
|
+
import os
|
|
9
|
+
from pathlib import Path
|
|
10
|
+
from server.shared.atomic_files import write_json
|
|
11
|
+
|
|
12
|
+
|
|
13
|
+
def register(sub):
|
|
14
|
+
parser = sub.add_parser('export-account', help="one person's data as one JSON file: account, records, owned sessions "
|
|
15
|
+
'and tasks, chats; never credentials')
|
|
16
|
+
parser.add_argument('email', nargs='?', help='the account to export (administrators only; default: your own)')
|
|
17
|
+
parser.add_argument('--out', help='the new file to write (default dikasta-account-<id>.json)')
|
|
18
|
+
parser.add_argument('--json', action='store_true', help='print the summary as JSON')
|
|
19
|
+
|
|
20
|
+
|
|
21
|
+
def summary(result, path):
|
|
22
|
+
rows = {table: len(items) for table, items in sorted((result.get('records') or {}).items())}
|
|
23
|
+
owned = {table: len(items) for table, items in sorted((result.get('owned') or {}).items())}
|
|
24
|
+
return {'path': str(path), 'account': (result.get('account') or {}).get('email'), 'records': rows, 'owned': owned,
|
|
25
|
+
'chats': len(result.get('chats') or []), 'truncated': result.get('truncated') or [],
|
|
26
|
+
'omitted': result.get('omitted') or []}
|
|
27
|
+
|
|
28
|
+
|
|
29
|
+
def run(args, host, out):
|
|
30
|
+
# Checked before the export, which takes up to minutes and is audited, so a bad path wastes neither.
|
|
31
|
+
chosen = Path(args.out).expanduser() if args.out else None
|
|
32
|
+
folder = (chosen.parent if chosen else Path('.')).resolve()
|
|
33
|
+
if chosen is not None and os.path.lexists(chosen):
|
|
34
|
+
raise SystemExit('dikasta: %s exists; the export never overwrites a file, so name a new one with --out' % chosen)
|
|
35
|
+
if not os.access(folder, os.W_OK | os.X_OK):
|
|
36
|
+
raise SystemExit('dikasta: cannot write in %s; run it from a folder you can write to, or give --out' % folder)
|
|
37
|
+
payload = {'email': args.email} if args.email else {}
|
|
38
|
+
result = host.request('POST', '/x/export_account', payload, timeout=150)
|
|
39
|
+
target = chosen or Path('dikasta-account-%s.json' % (result.get('account') or {}).get('id', 'unknown'))
|
|
40
|
+
try:
|
|
41
|
+
write_json(target, result, mode=0o600, exclusive=True, indent=2, sort_keys=True, streaming=True)
|
|
42
|
+
except FileExistsError:
|
|
43
|
+
raise SystemExit('dikasta: %s exists; the export never overwrites a file, so name a new one with --out' % target) from None
|
|
44
|
+
except OSError as exc:
|
|
45
|
+
raise SystemExit('dikasta: cannot write %s: %s' % (target, exc.strerror or exc)) from None
|
|
46
|
+
told = summary(result, target.resolve())
|
|
47
|
+
if args.json:
|
|
48
|
+
out(json.dumps(told, indent=2))
|
|
49
|
+
return told
|
|
50
|
+
out('Wrote %s for %s: %d record tables, %d owned sessions and tasks, %d chats.' % (
|
|
51
|
+
told['path'], told['account'], len(told['records']), sum(told['owned'].values()), told['chats']))
|
|
52
|
+
if told['truncated']:
|
|
53
|
+
out('Cut at the row limit: ' + ', '.join(told['truncated']))
|
|
54
|
+
out('Not in it: ' + '; '.join(told['omitted']))
|
|
55
|
+
return told
|
active_command.py
ADDED
|
@@ -0,0 +1,61 @@
|
|
|
1
|
+
"""`dikasta active [--stop TASK]`: the account's running terminal tasks, and a way to stop one.
|
|
2
|
+
|
|
3
|
+
An account runs at most two terminal tasks at once (server/chat/native_delivery.py). A task
|
|
4
|
+
started in another terminal, or one whose terminal was closed, holds a slot until it ends, so
|
|
5
|
+
this lists what holds them and stops one from anywhere: the same cancel as Ctrl-C in the
|
|
6
|
+
task's own terminal, which keeps completed work.
|
|
7
|
+
"""
|
|
8
|
+
import json
|
|
9
|
+
import time
|
|
10
|
+
|
|
11
|
+
|
|
12
|
+
def register(sub):
|
|
13
|
+
parser = sub.add_parser('active', help='list your running terminal tasks, or stop one with --stop')
|
|
14
|
+
parser.add_argument('--stop', metavar='TASK', help='stop this task (its id from the list); completed work is kept')
|
|
15
|
+
parser.add_argument('--release-writes', action='store_true',
|
|
16
|
+
help='with --stop: also release the folder from an edit that was cut off, after checking the files')
|
|
17
|
+
parser.add_argument('--json', action='store_true', help='print the result as JSON instead of text')
|
|
18
|
+
|
|
19
|
+
|
|
20
|
+
def age(updated, now=None):
|
|
21
|
+
seconds = max(0, int((now or time.time()) - float(updated or 0)))
|
|
22
|
+
return '%d min' % (seconds // 60) if seconds >= 60 else '%d s' % seconds
|
|
23
|
+
|
|
24
|
+
|
|
25
|
+
def describe(task, now=None):
|
|
26
|
+
from terminal_ui import plain
|
|
27
|
+
prompt = ' '.join(str(task.get('prompt') or '').split())
|
|
28
|
+
if len(prompt) > 80:
|
|
29
|
+
prompt = prompt[:80] + '…'
|
|
30
|
+
return plain(' %s %s, %s, updated %s ago: %s' % (task.get('delivery_id'), task.get('intent') or 'task',
|
|
31
|
+
task.get('stage') or 'running', age(task.get('updated'), now), prompt))
|
|
32
|
+
|
|
33
|
+
|
|
34
|
+
def run(args, host, out):
|
|
35
|
+
as_json = getattr(args, 'json', False)
|
|
36
|
+
if getattr(args, 'release_writes', False) and not args.stop:
|
|
37
|
+
raise SystemExit('--release-writes goes with --stop TASK')
|
|
38
|
+
if args.stop:
|
|
39
|
+
request = {'action': 'cancel', 'delivery_id': args.stop}
|
|
40
|
+
if getattr(args, 'release_writes', False):
|
|
41
|
+
request['release_writes'] = True
|
|
42
|
+
stopped = host.request('POST', '/native/deliveries', request)
|
|
43
|
+
out(json.dumps(stopped, indent=2) if as_json else 'Stopping %s; completed work is kept.%s' % (
|
|
44
|
+
args.stop, ' Its claim on this folder is released.' if request.get('release_writes') else ''))
|
|
45
|
+
return
|
|
46
|
+
listed = host.request('POST', '/native/deliveries', {'action': 'list'}).get('tasks') or []
|
|
47
|
+
tasks = [task for task in listed if task.get('running')]
|
|
48
|
+
# A task a service update stopped waits here when no terminal is attached to resume it (decision 0212).
|
|
49
|
+
held = [task for task in listed if not task.get('running') and (task.get('stop_reason') or {}).get('code') == 'maintenance']
|
|
50
|
+
if as_json:
|
|
51
|
+
out(json.dumps({'tasks': tasks, 'paused_for_update': held}, indent=2))
|
|
52
|
+
return
|
|
53
|
+
for task in held:
|
|
54
|
+
out('Paused for a service update: dikasta resume %s' % task['delivery_id'])
|
|
55
|
+
if not tasks:
|
|
56
|
+
out('No terminal task is running for this account.')
|
|
57
|
+
return
|
|
58
|
+
out('Running terminal tasks (at most two at once):')
|
|
59
|
+
for task in tasks:
|
|
60
|
+
out(describe(task))
|
|
61
|
+
out('Stop one with `dikasta active --stop <task>`.')
|
attachments.py
ADDED
|
@@ -0,0 +1,488 @@
|
|
|
1
|
+
"""Bounded client-local snapshots. Outbound checks mirror outbound.py; parity tested.
|
|
2
|
+
|
|
3
|
+
Only explicit path mentions are expanded. Host paths must remain host references.
|
|
4
|
+
"""
|
|
5
|
+
from dataclasses import dataclass
|
|
6
|
+
from pathlib import Path
|
|
7
|
+
import codecs
|
|
8
|
+
import fnmatch
|
|
9
|
+
import hashlib
|
|
10
|
+
import json
|
|
11
|
+
import os
|
|
12
|
+
import re
|
|
13
|
+
import shlex
|
|
14
|
+
import stat
|
|
15
|
+
|
|
16
|
+
from server.shared import image_attachments
|
|
17
|
+
|
|
18
|
+
DEFAULT_NEVER_SEND = ('.env', '.env.*', '*.pem', '*.key', '*.p12', '*.pfx', 'id_rsa', 'id_rsa.*', 'id_ed25519', 'id_ed25519.*',
|
|
19
|
+
'id_ecdsa', 'id_ecdsa.*', 'credentials.json', 'auth.json', '.netrc', '*.keystore', '*.jks', '.npmrc', '.pypirc',
|
|
20
|
+
'operator.env', 'runtime/operator/*',
|
|
21
|
+
# The platform's root secrets and the key that seals the secrets table (decision 0227).
|
|
22
|
+
'secrets.env', 'secrets.key')
|
|
23
|
+
SECRET_NAME = re.compile(r'(KEY|SECRET|TOKEN|PASSWORD|PASSWD|CREDENTIAL)', re.I)
|
|
24
|
+
ASSIGNMENT = re.compile(r'^\s*(?:export\s+|const\s+|let\s+|var\s+)?["\']?([A-Za-z_][A-Za-z0-9_]*)["\']?\s*[=:]\s*(["\'`]?)([^\s"\'`;,]{8,})')
|
|
25
|
+
# Committed templates hold placeholders, never values, and are meant to be read.
|
|
26
|
+
TEMPLATE_SUFFIXES = ('.example', '.sample', '.template', '.dist', '.defaults')
|
|
27
|
+
# A complete key block: the header, a body of base64 (raw or with \n escapes, as JSON holds it)
|
|
28
|
+
# and the matching end line. A header alone is code that handles keys, not a key.
|
|
29
|
+
KEY_BLOCK = r'-----BEGIN ([A-Z ]*)PRIVATE KEY-----(?:\\n|\s)+(?:[A-Za-z0-9+/=]|\\n|\s){100,}?-----END \1PRIVATE KEY-----'
|
|
30
|
+
PATTERNS = (
|
|
31
|
+
('a JSON private key', re.compile(r'"private_key"\s*:\s*"' + KEY_BLOCK)),
|
|
32
|
+
('a private key block', re.compile(KEY_BLOCK)),
|
|
33
|
+
('an AWS access key id', re.compile(r'\bAKIA[0-9A-Z]{16}\b')),
|
|
34
|
+
('a GitHub token', re.compile(r'\bgh[pousr]_[A-Za-z0-9]{20,}\b')),
|
|
35
|
+
('a Slack token', re.compile(r'\bxox[abprs]-[A-Za-z0-9-]{10,}\b')),
|
|
36
|
+
('an Anthropic or OpenAI key', re.compile(r'\bsk-(?:ant-)?[A-Za-z0-9_-]{20,}\b')),
|
|
37
|
+
('a Google API key', re.compile(r'\bAIza[A-Za-z0-9_-]{20,}\b')),
|
|
38
|
+
)
|
|
39
|
+
MIN_ASSIGNMENTS = 3
|
|
40
|
+
SNIFF_BYTES = 200_000
|
|
41
|
+
WITHHELD = '[withheld: a secret-looking value]'
|
|
42
|
+
|
|
43
|
+
def looks_like_key_store(text, full=False):
|
|
44
|
+
"""Why a file's content looks like a key store, or None."""
|
|
45
|
+
sample = str(text or '') if full else str(text or '')[:SNIFF_BYTES]
|
|
46
|
+
for reason, pattern in PATTERNS:
|
|
47
|
+
if pattern.search(sample):
|
|
48
|
+
return 'it holds ' + reason
|
|
49
|
+
assignments = 0
|
|
50
|
+
for line in sample.splitlines():
|
|
51
|
+
if secret_assignment(line):
|
|
52
|
+
assignments += 1
|
|
53
|
+
if assignments >= MIN_ASSIGNMENTS:
|
|
54
|
+
return 'it holds %d secret-looking assignments' % assignments
|
|
55
|
+
return None
|
|
56
|
+
|
|
57
|
+
|
|
58
|
+
def random_looking(value):
|
|
59
|
+
"""Whether a value looks like a generated secret rather than a word, a URL, a path or a name:
|
|
60
|
+
long, mixing letters and digits, with little repetition."""
|
|
61
|
+
if len(value) < 16 or '://' in value or value.startswith(('/', './', '~', '$', '{', '<', 'process.', 'os.')):
|
|
62
|
+
return False
|
|
63
|
+
if not (re.search(r'[A-Za-z]', value) and re.search(r'[0-9]', value)):
|
|
64
|
+
return False
|
|
65
|
+
segments = re.split(r'[-_.]', value)
|
|
66
|
+
if re.fullmatch(r'[a-z0-9]+(?:[-_.][a-z0-9]+)*', value) and not any(
|
|
67
|
+
len(segment) >= 12 and re.search(r'[a-z]', segment) and re.search(r'[0-9]', segment) for segment in segments):
|
|
68
|
+
return False # a slug or a dotted name such as app-state-v2 or api.v1.token, with no random part
|
|
69
|
+
import math
|
|
70
|
+
counts = {ch: value.count(ch) for ch in set(value)}
|
|
71
|
+
entropy = -sum(n / len(value) * math.log2(n / len(value)) for n in counts.values())
|
|
72
|
+
return entropy >= 3.5
|
|
73
|
+
|
|
74
|
+
|
|
75
|
+
def secret_assignment(line):
|
|
76
|
+
"""The match of an assignment whose name says secret and whose value looks generated, or None."""
|
|
77
|
+
match = ASSIGNMENT.match(line)
|
|
78
|
+
if match and SECRET_NAME.search(match.group(1)) and random_looking(match.group(3)):
|
|
79
|
+
return match
|
|
80
|
+
return None
|
|
81
|
+
|
|
82
|
+
|
|
83
|
+
class AttachmentError(ValueError):
|
|
84
|
+
pass
|
|
85
|
+
|
|
86
|
+
|
|
87
|
+
def normalize_path(value):
|
|
88
|
+
value = str(value).strip()
|
|
89
|
+
if value.startswith('@'):
|
|
90
|
+
value = value[1:]
|
|
91
|
+
if value.startswith(('"', "'")):
|
|
92
|
+
try:
|
|
93
|
+
parts = shlex.split(value)
|
|
94
|
+
except ValueError as exc:
|
|
95
|
+
raise AttachmentError('Unclosed path quote') from exc
|
|
96
|
+
if len(parts) != 1:
|
|
97
|
+
raise AttachmentError('Expected one quoted path')
|
|
98
|
+
value = parts[0]
|
|
99
|
+
if not value or any(ord(c) < 32 or ord(c) == 127 for c in value):
|
|
100
|
+
raise AttachmentError('Expected a file path')
|
|
101
|
+
return value
|
|
102
|
+
|
|
103
|
+
|
|
104
|
+
# Deliberately excludes @person and email addresses. Completion emits @./path.
|
|
105
|
+
MENTION = re.compile(r"(?<!\S)@(?:\"(?:[^\"\\]|\\.)*\"|'[^']*'|(?:\./|\.\./|/)[^\s]+)")
|
|
106
|
+
|
|
107
|
+
|
|
108
|
+
def extract_mentions(text):
|
|
109
|
+
matches = list(MENTION.finditer(text))
|
|
110
|
+
starts = {match.start() for match in matches}
|
|
111
|
+
for prefix in re.finditer(r"(?<!\S)@(?:\\?['\"]|\./|\.\./|/)", text):
|
|
112
|
+
if prefix.start() not in starts:
|
|
113
|
+
raise AttachmentError('Invalid explicit file mention; close the path quote')
|
|
114
|
+
return [(m.start(), m.end(), normalize_path(m.group()[1:])) for m in matches]
|
|
115
|
+
|
|
116
|
+
|
|
117
|
+
# A remote session's reference to a file in the host repository. The client sends only
|
|
118
|
+
# the path; the coordinator reads it on the host under its own policy.
|
|
119
|
+
HOST_MENTION = re.compile(r"""(?<!\S)@host:(?:"(?:[^"\\]|\\.)*"|'[^']*'|[^\s"']+)""")
|
|
120
|
+
|
|
121
|
+
|
|
122
|
+
def extract_host_references(text):
|
|
123
|
+
found = []
|
|
124
|
+
for match in HOST_MENTION.finditer(text):
|
|
125
|
+
found.append((match.start(), match.end(), normalize_path(match.group()[len('@host:'):])))
|
|
126
|
+
for prefix in re.finditer(r"(?<!\S)@host:", text):
|
|
127
|
+
if not any(start == prefix.start() for start, _, _ in found):
|
|
128
|
+
raise AttachmentError('Invalid host reference; name a path after @host:')
|
|
129
|
+
return found
|
|
130
|
+
|
|
131
|
+
|
|
132
|
+
def path_refusal(root, path):
|
|
133
|
+
try:
|
|
134
|
+
relative = str(Path(path).resolve().relative_to(Path(root).resolve()))
|
|
135
|
+
absolute = Path(os.path.abspath(path))
|
|
136
|
+
# macOS /var and /tmp aliases may precede the project. Preserve aliases
|
|
137
|
+
# inside the project while accepting an equivalent project-root prefix.
|
|
138
|
+
boundary = next((parent for parent in absolute.parents if parent.resolve() == Path(root).resolve()), None)
|
|
139
|
+
if boundary is None:
|
|
140
|
+
return 'Path is outside the local client project'
|
|
141
|
+
lexical = str(absolute.relative_to(boundary))
|
|
142
|
+
except (ValueError, OSError):
|
|
143
|
+
return 'Path is outside the local client project'
|
|
144
|
+
policy = Path(root) / '.dikasta' / 'policy.json'
|
|
145
|
+
globs = [(glob, True) for glob in DEFAULT_NEVER_SEND]
|
|
146
|
+
if policy.exists():
|
|
147
|
+
try:
|
|
148
|
+
with policy.open('rb') as handle:
|
|
149
|
+
raw = handle.read(65537)
|
|
150
|
+
if len(raw) > 65536:
|
|
151
|
+
raise ValueError('policy exceeds 64 KiB')
|
|
152
|
+
data = json.loads(raw)
|
|
153
|
+
extra = data.get('never_send') or []
|
|
154
|
+
if not isinstance(extra, list) or not all(isinstance(x, str) for x in extra):
|
|
155
|
+
raise ValueError('never_send must be a list of strings')
|
|
156
|
+
globs.extend((glob, False) for glob in extra)
|
|
157
|
+
except (OSError, ValueError, AttributeError) as exc:
|
|
158
|
+
return 'Cannot safely load local outbound policy: ' + str(exc)
|
|
159
|
+
for glob, default in globs:
|
|
160
|
+
for name in {relative, lexical}:
|
|
161
|
+
if default and Path(name).name.lower().endswith(TEMPLATE_SUFFIXES):
|
|
162
|
+
continue
|
|
163
|
+
if any(fnmatch.fnmatch(value, glob) for value in (Path(name).name, name)) or fnmatch.fnmatch(name, '*/' + glob):
|
|
164
|
+
return 'Path is on the never-send list (' + glob + ')'
|
|
165
|
+
return None
|
|
166
|
+
|
|
167
|
+
|
|
168
|
+
def _identity(info):
|
|
169
|
+
return (info.st_dev, info.st_ino, info.st_size, info.st_mtime_ns, info.st_ctime_ns)
|
|
170
|
+
|
|
171
|
+
|
|
172
|
+
def _open_local(root, path):
|
|
173
|
+
"""Open via directory descriptors so a raced directory symlink cannot escape."""
|
|
174
|
+
parts = Path(path).relative_to(root).parts
|
|
175
|
+
if not parts:
|
|
176
|
+
raise AttachmentError('Attachments must be regular files')
|
|
177
|
+
nofollow = getattr(os, 'O_NOFOLLOW', 0)
|
|
178
|
+
directory = os.open(root, os.O_RDONLY | os.O_DIRECTORY | nofollow)
|
|
179
|
+
try:
|
|
180
|
+
for part in parts[:-1]:
|
|
181
|
+
next_directory = os.open(part, os.O_RDONLY | os.O_DIRECTORY | nofollow, dir_fd=directory)
|
|
182
|
+
os.close(directory)
|
|
183
|
+
directory = next_directory
|
|
184
|
+
return os.open(parts[-1], os.O_RDONLY | os.O_NONBLOCK | nofollow, dir_fd=directory)
|
|
185
|
+
finally:
|
|
186
|
+
os.close(directory)
|
|
187
|
+
|
|
188
|
+
|
|
189
|
+
@dataclass(frozen=True)
|
|
190
|
+
class Attachment:
|
|
191
|
+
id: int
|
|
192
|
+
path: str
|
|
193
|
+
text: str
|
|
194
|
+
size_bytes: int
|
|
195
|
+
included_bytes: int
|
|
196
|
+
sha256: str
|
|
197
|
+
identity: tuple
|
|
198
|
+
source: str = 'local-client'
|
|
199
|
+
requested_path: str = ''
|
|
200
|
+
kind = 'text'
|
|
201
|
+
|
|
202
|
+
@property
|
|
203
|
+
def omitted_bytes(self):
|
|
204
|
+
return self.size_bytes - self.included_bytes
|
|
205
|
+
|
|
206
|
+
def policy_text(self):
|
|
207
|
+
return self.text
|
|
208
|
+
|
|
209
|
+
def metadata(self):
|
|
210
|
+
return {'id': self.id, 'path': self.path, 'source': self.source,
|
|
211
|
+
'size_bytes': self.size_bytes, 'included_bytes': self.included_bytes,
|
|
212
|
+
'omitted_bytes': self.omitted_bytes, 'sha256': self.sha256,
|
|
213
|
+
'encoding': 'UTF-8', 'hash_scope': 'included snapshot bytes'}
|
|
214
|
+
|
|
215
|
+
def render(self):
|
|
216
|
+
return '[Attachment ' + json.dumps(self.metadata(), ensure_ascii=False) + ']\n' + self.text + '\n[End attachment]'
|
|
217
|
+
|
|
218
|
+
|
|
219
|
+
class PendingAttachments:
|
|
220
|
+
def __init__(self, root, max_bytes=200_000, max_total_bytes=1_000_000, max_image_bytes=image_attachments.MAX_IMAGE_BYTES):
|
|
221
|
+
self.root = Path(root).expanduser().resolve()
|
|
222
|
+
self.max_bytes = max_bytes
|
|
223
|
+
self.max_total_bytes = max_total_bytes
|
|
224
|
+
self.max_image_bytes = max_image_bytes
|
|
225
|
+
self._items = {}
|
|
226
|
+
self._next = 1
|
|
227
|
+
if not 1 <= max_bytes <= SNIFF_BYTES or max_total_bytes < 1:
|
|
228
|
+
raise ValueError('Attachment byte limits must be positive and per-file limit at most 200000')
|
|
229
|
+
|
|
230
|
+
def add(self, value):
|
|
231
|
+
candidate = Path(normalize_path(value)).expanduser()
|
|
232
|
+
candidate = candidate if candidate.is_absolute() else self.root / candidate
|
|
233
|
+
try:
|
|
234
|
+
path = candidate.resolve(strict=True)
|
|
235
|
+
reason = path_refusal(self.root, candidate)
|
|
236
|
+
if reason:
|
|
237
|
+
raise AttachmentError(reason)
|
|
238
|
+
# O_NONBLOCK avoids hanging on FIFOs; reject all non-regular files.
|
|
239
|
+
fd = _open_local(self.root, path)
|
|
240
|
+
with os.fdopen(fd, 'rb') as handle:
|
|
241
|
+
before = os.fstat(handle.fileno())
|
|
242
|
+
if not stat.S_ISREG(before.st_mode):
|
|
243
|
+
raise AttachmentError('Attachments must be regular files')
|
|
244
|
+
named_image = path.suffix.lower() in image_attachments.EXTENSIONS
|
|
245
|
+
if named_image and before.st_size > self.max_image_bytes:
|
|
246
|
+
raise AttachmentError('Image is %d bytes; the limit is %d (base64 must fit the host\'s %d-byte message limit)' % (
|
|
247
|
+
before.st_size, self.max_image_bytes, image_attachments.HOST_REQUEST_BYTES))
|
|
248
|
+
# One bounded read; a file whose first bytes say image is bounded by the image limit.
|
|
249
|
+
raw = handle.read((self.max_image_bytes if named_image else self.max_bytes) + 1)
|
|
250
|
+
image = named_image or image_attachments.sniff(raw[:16]) is not None
|
|
251
|
+
if image and before.st_size > self.max_image_bytes:
|
|
252
|
+
raise AttachmentError('Image is %d bytes; the limit is %d (base64 must fit the host\'s %d-byte message limit)' % (
|
|
253
|
+
before.st_size, self.max_image_bytes, image_attachments.HOST_REQUEST_BYTES))
|
|
254
|
+
if image and not named_image:
|
|
255
|
+
raw += handle.read(max(0, self.max_image_bytes + 1 - len(raw)))
|
|
256
|
+
after = os.fstat(handle.fileno())
|
|
257
|
+
if _identity(before) != _identity(after) or _identity(path.stat()) != _identity(after):
|
|
258
|
+
raise AttachmentError('File changed while reading; attach it again')
|
|
259
|
+
if image:
|
|
260
|
+
return self._add_image(path, candidate, raw, before)
|
|
261
|
+
truncated = len(raw) > self.max_bytes
|
|
262
|
+
raw = raw[:self.max_bytes]
|
|
263
|
+
if b'\x00' in raw:
|
|
264
|
+
raise AttachmentError('Binary attachments are unsupported')
|
|
265
|
+
try:
|
|
266
|
+
decoder = codecs.getincrementaldecoder('utf-8')('strict')
|
|
267
|
+
text = decoder.decode(raw, final=not truncated)
|
|
268
|
+
pending, _ = decoder.getstate()
|
|
269
|
+
raw = raw[:len(raw) - len(pending)]
|
|
270
|
+
except UnicodeDecodeError as exc:
|
|
271
|
+
raise AttachmentError('Attachment is not valid UTF-8 text') from exc
|
|
272
|
+
if any(ord(c) < 32 and c not in '\n\r\t' for c in text):
|
|
273
|
+
raise AttachmentError('Binary/control-byte attachments are unsupported')
|
|
274
|
+
reason = looks_like_key_store(text)
|
|
275
|
+
if reason:
|
|
276
|
+
raise AttachmentError('Outbound policy refused attachment: ' + reason)
|
|
277
|
+
if sum(item.included_bytes for item in self._items.values() if item.kind == 'text') + len(raw) > self.max_total_bytes:
|
|
278
|
+
raise AttachmentError('Pending attachments exceed total byte limit; remove one first')
|
|
279
|
+
item = Attachment(self._next, str(path), text, before.st_size, len(raw),
|
|
280
|
+
hashlib.sha256(raw).hexdigest(), _identity(before), requested_path=str(candidate))
|
|
281
|
+
self._items[item.id] = item
|
|
282
|
+
self._next += 1
|
|
283
|
+
return item
|
|
284
|
+
except (OSError, RuntimeError) as exc:
|
|
285
|
+
raise AttachmentError('Cannot read attachment: ' + str(exc)) from exc
|
|
286
|
+
|
|
287
|
+
def _add_image(self, path, candidate, raw, before):
|
|
288
|
+
if len(raw) > self.max_image_bytes or len(raw) != before.st_size:
|
|
289
|
+
raise AttachmentError('Image size changed while reading; attach it again')
|
|
290
|
+
try:
|
|
291
|
+
media_type, width, height, metadata, text = image_attachments.inspect(raw, path.name)
|
|
292
|
+
except image_attachments.ImageError as exc:
|
|
293
|
+
raise AttachmentError(str(exc)) from exc
|
|
294
|
+
reason = looks_like_key_store(text, full=True)
|
|
295
|
+
if reason:
|
|
296
|
+
raise AttachmentError('Outbound policy refused attachment: its metadata ' + reason.replace('it holds', 'holds'))
|
|
297
|
+
if sum(item.size_bytes for item in self._items.values() if item.kind == 'image') + len(raw) > self.max_image_bytes:
|
|
298
|
+
raise AttachmentError('Pending images exceed the %d-byte image limit; remove one first' % self.max_image_bytes)
|
|
299
|
+
item = image_attachments.ImageAttachment(
|
|
300
|
+
self._next, str(path), raw, len(raw), hashlib.sha256(raw).hexdigest(), _identity(before),
|
|
301
|
+
media_type, width, height, tuple(metadata), text, requested_path=str(candidate))
|
|
302
|
+
self._items[item.id] = item
|
|
303
|
+
self._next += 1
|
|
304
|
+
return item
|
|
305
|
+
|
|
306
|
+
def add_clipboard_image(self, raw):
|
|
307
|
+
"""An image pasted from the clipboard. It has no file, so there is no path policy or
|
|
308
|
+
change check at send time; its metadata is still scanned like a file's."""
|
|
309
|
+
name = 'clipboard-%d.png' % self._next
|
|
310
|
+
try:
|
|
311
|
+
media_type, width, height, metadata, text = image_attachments.inspect(raw, name)
|
|
312
|
+
except image_attachments.ImageError as exc:
|
|
313
|
+
raise AttachmentError(str(exc)) from exc
|
|
314
|
+
reason = looks_like_key_store(text, full=True)
|
|
315
|
+
if reason:
|
|
316
|
+
raise AttachmentError('Outbound policy refused attachment: its metadata ' + reason.replace('it holds', 'holds'))
|
|
317
|
+
if sum(item.size_bytes for item in self._items.values() if item.kind == 'image') + len(raw) > self.max_image_bytes:
|
|
318
|
+
raise AttachmentError('Pending images exceed the %d-byte image limit; remove one first' % self.max_image_bytes)
|
|
319
|
+
item = image_attachments.ImageAttachment(
|
|
320
|
+
self._next, name, raw, len(raw), hashlib.sha256(raw).hexdigest(), (), media_type, width, height,
|
|
321
|
+
tuple(metadata), text, source='clipboard')
|
|
322
|
+
self._items[item.id] = item
|
|
323
|
+
self._next += 1
|
|
324
|
+
return item
|
|
325
|
+
|
|
326
|
+
def image_blocks(self, chat):
|
|
327
|
+
"""The pending images as content blocks, or AttachmentError when this chat's backend cannot take them."""
|
|
328
|
+
images = [item for item in self._items.values() if item.kind == 'image']
|
|
329
|
+
if not images:
|
|
330
|
+
return []
|
|
331
|
+
refusal = image_attachments.backend_refusal(chat)
|
|
332
|
+
if refusal:
|
|
333
|
+
raise AttachmentError(refusal)
|
|
334
|
+
return [item.block() for item in images]
|
|
335
|
+
|
|
336
|
+
def list(self):
|
|
337
|
+
return list(self._items.values())
|
|
338
|
+
|
|
339
|
+
def preview(self, identifier):
|
|
340
|
+
try:
|
|
341
|
+
return self._items[int(identifier)].render()
|
|
342
|
+
except (KeyError, ValueError, TypeError) as exc:
|
|
343
|
+
raise AttachmentError('No pending attachment with that id') from exc
|
|
344
|
+
|
|
345
|
+
def remove(self, identifier):
|
|
346
|
+
try:
|
|
347
|
+
return self._items.pop(int(identifier))
|
|
348
|
+
except (KeyError, ValueError, TypeError) as exc:
|
|
349
|
+
raise AttachmentError('No pending attachment with that id') from exc
|
|
350
|
+
|
|
351
|
+
def clear(self):
|
|
352
|
+
self._items.clear()
|
|
353
|
+
|
|
354
|
+
def render(self):
|
|
355
|
+
for item in self._items.values():
|
|
356
|
+
if getattr(item, 'source', '') == 'clipboard':
|
|
357
|
+
reason = looks_like_key_store(item.policy_text(), full=True)
|
|
358
|
+
if reason:
|
|
359
|
+
raise AttachmentError(reason)
|
|
360
|
+
continue
|
|
361
|
+
try:
|
|
362
|
+
if _identity(Path(item.path).stat()) != item.identity:
|
|
363
|
+
raise AttachmentError('File changed since preview; remove and attach again: ' + item.path)
|
|
364
|
+
reason = (path_refusal(self.root, item.path) or
|
|
365
|
+
path_refusal(self.root, item.requested_path or item.path) or
|
|
366
|
+
looks_like_key_store(item.policy_text(), full=item.kind == 'image'))
|
|
367
|
+
if reason:
|
|
368
|
+
raise AttachmentError(reason)
|
|
369
|
+
# File timestamps can stay equal across a same-size rewrite.
|
|
370
|
+
with os.fdopen(_open_local(self.root, item.path), 'rb') as handle:
|
|
371
|
+
before = os.fstat(handle.fileno())
|
|
372
|
+
if not stat.S_ISREG(before.st_mode) or _identity(before) != item.identity:
|
|
373
|
+
raise AttachmentError('File changed since preview; remove and attach again: ' + item.path)
|
|
374
|
+
raw = handle.read(item.included_bytes)
|
|
375
|
+
after = os.fstat(handle.fileno())
|
|
376
|
+
if (hashlib.sha256(raw).hexdigest() != item.sha256 or
|
|
377
|
+
_identity(after) != item.identity or _identity(Path(item.path).stat()) != item.identity):
|
|
378
|
+
raise AttachmentError('File changed since preview; remove and attach again: ' + item.path)
|
|
379
|
+
except OSError as exc:
|
|
380
|
+
raise AttachmentError('Attachment is no longer readable: ' + item.path) from exc
|
|
381
|
+
return '\n\n'.join(item.render() for item in self._items.values())
|
|
382
|
+
|
|
383
|
+
|
|
384
|
+
def host_completions(fragment, lister, start_position):
|
|
385
|
+
"""@host: completions from the host listing; every item says it lives on the host."""
|
|
386
|
+
from prompt_toolkit.completion import Completion
|
|
387
|
+
rest = fragment[len('host:'):].lstrip('"' + "'")
|
|
388
|
+
try:
|
|
389
|
+
entries = lister(rest)
|
|
390
|
+
except Exception:
|
|
391
|
+
return # a host that cannot list offers no completions; typing goes on
|
|
392
|
+
for entry in entries[:200]:
|
|
393
|
+
path = str(entry.get('path') or '')
|
|
394
|
+
if not path:
|
|
395
|
+
continue
|
|
396
|
+
quoted = json.dumps(path, ensure_ascii=False) if any(c.isspace() or c in '\"\\\'' for c in path) else path
|
|
397
|
+
if entry.get('kind') == 'directory':
|
|
398
|
+
meta = 'host repository directory'
|
|
399
|
+
else:
|
|
400
|
+
meta = 'host repository reference · %s bytes' % entry.get('size_bytes', '?')
|
|
401
|
+
if entry.get('policy') == 'ask':
|
|
402
|
+
meta += ' · reading asks first'
|
|
403
|
+
yield Completion('@host:' + quoted, start_position=start_position, display=path, display_meta=meta)
|
|
404
|
+
|
|
405
|
+
|
|
406
|
+
def make_completer(commands, root=None, descriptions=None, host_lister=None, local_lister=None):
|
|
407
|
+
"""Optional prompt_toolkit completion: client-local files, and in a remote session
|
|
408
|
+
host repository paths under @host:, each labelled with the side it comes from."""
|
|
409
|
+
from prompt_toolkit.completion import Completer, Completion
|
|
410
|
+
from terminal_ui import plain
|
|
411
|
+
metadata = descriptions or (commands if isinstance(commands, dict) else {})
|
|
412
|
+
|
|
413
|
+
class LocalCompleter(Completer):
|
|
414
|
+
def get_completions(self, document, complete_event):
|
|
415
|
+
text = document.text_before_cursor
|
|
416
|
+
match = re.search(r'''(?<!\S)@((?:host:)?(?:"[^"]*|'[^']*|[^\s]*))$''', text)
|
|
417
|
+
if match and host_lister is not None and match.group(1).startswith('host:'):
|
|
418
|
+
yield from host_completions(match.group(1), host_lister, match.start() - len(text))
|
|
419
|
+
return
|
|
420
|
+
if match and host_lister is not None and 'host:'.startswith(match.group(1)):
|
|
421
|
+
yield Completion('@host:', start_position=match.start() - len(text), display='@host:',
|
|
422
|
+
display_meta='browse the host repository (remote session)')
|
|
423
|
+
if not match or root is None:
|
|
424
|
+
command_start = 0 if text.startswith('/') and not any(c.isspace() for c in text) else None
|
|
425
|
+
if command_start is None:
|
|
426
|
+
# Like the reference composer, allow an explicit Tab to complete
|
|
427
|
+
# a slash command inside a sentence without treating URL/path
|
|
428
|
+
# slashes as commands or changing text before the token.
|
|
429
|
+
command = re.search(r'(?<!\S)(/[a-zA-Z0-9_:-]*)$', text)
|
|
430
|
+
if command and command.start(1) > 0:
|
|
431
|
+
command_start = command.start(1)
|
|
432
|
+
if command_start is not None:
|
|
433
|
+
# The / palette: grouped, and searchable by name or description.
|
|
434
|
+
from command_help import palette
|
|
435
|
+
fragment = text[command_start:]
|
|
436
|
+
for command, meta in palette(fragment, commands, metadata):
|
|
437
|
+
yield Completion(command, start_position=command_start - len(text), display=command,
|
|
438
|
+
display_meta=plain(meta))
|
|
439
|
+
return
|
|
440
|
+
fragment = match.group(1).lstrip('"'+"'")
|
|
441
|
+
if local_lister is not None:
|
|
442
|
+
for row in local_lister(fragment):
|
|
443
|
+
relative = row['path']
|
|
444
|
+
replacement = '@' + (json.dumps(relative, ensure_ascii=False) if any(c.isspace() or c in '\"\\\'' for c in relative) else relative)
|
|
445
|
+
yield Completion(replacement, start_position=match.start() - len(text),
|
|
446
|
+
display=plain(relative), display_meta='opened project source')
|
|
447
|
+
return
|
|
448
|
+
base = Path(root).resolve()
|
|
449
|
+
candidate = Path(fragment) if fragment.startswith('/') else base / fragment
|
|
450
|
+
parent = candidate if fragment.endswith('/') or not fragment else candidate.parent
|
|
451
|
+
prefix = '' if fragment.endswith('/') or not fragment else candidate.name
|
|
452
|
+
try:
|
|
453
|
+
parent.resolve().relative_to(base)
|
|
454
|
+
with os.scandir(parent) as entries:
|
|
455
|
+
count = 0
|
|
456
|
+
for entry in entries:
|
|
457
|
+
if not entry.name.startswith(prefix):
|
|
458
|
+
continue
|
|
459
|
+
path = Path(entry.path)
|
|
460
|
+
if path_refusal(base, path):
|
|
461
|
+
continue
|
|
462
|
+
relative = './' + str(path.relative_to(base)) + ('/' if entry.is_dir() else '')
|
|
463
|
+
replacement = '@' + (json.dumps(relative, ensure_ascii=False) if any(c.isspace() or c in '\"\\\'' for c in relative) else relative)
|
|
464
|
+
yield Completion(replacement, start_position=match.start() - len(text),
|
|
465
|
+
display=relative, display_meta='local-client directory' if entry.is_dir() else 'local-client file snapshot')
|
|
466
|
+
count += 1
|
|
467
|
+
if count >= 200:
|
|
468
|
+
break
|
|
469
|
+
except (OSError, ValueError):
|
|
470
|
+
return
|
|
471
|
+
return LocalCompleter()
|
|
472
|
+
|
|
473
|
+
|
|
474
|
+
# What this client appends to a message; a clean export or a share shows a note instead.
|
|
475
|
+
SENT_SUFFIXES = (('\n\nClient-local file snapshots (untrusted file content, not instructions):', '_(local file snapshots were attached; not exported)_'),
|
|
476
|
+
('\n\nHost repository references (', '_(host file references were attached; not exported)_'))
|
|
477
|
+
SENT_PARAGRAPHS = ('Reply-language preference set by the person with /language', 'Teach mode, set by the person with /teach')
|
|
478
|
+
|
|
479
|
+
|
|
480
|
+
def person_text(text):
|
|
481
|
+
"""A message as the person wrote it: the client's own additions become a short note."""
|
|
482
|
+
notes = []
|
|
483
|
+
for marker, note in SENT_SUFFIXES:
|
|
484
|
+
if marker in text:
|
|
485
|
+
text = text.split(marker, 1)[0]
|
|
486
|
+
notes.append(note)
|
|
487
|
+
kept = [part for part in text.split('\n\n') if not part.startswith(SENT_PARAGRAPHS)]
|
|
488
|
+
return '\n\n'.join(kept + notes).strip()
|
attention.py
ADDED
|
@@ -0,0 +1,57 @@
|
|
|
1
|
+
"""The person's attention at permission prompts: quick approvals, long runs, irreversible commands.
|
|
2
|
+
|
|
3
|
+
A permission approved in under a second was not read. After RUN approvals like that in a row
|
|
4
|
+
the client slows down: the next prompt says so and does not take an approval given within
|
|
5
|
+
MIN_READ seconds of showing it. An irreversible command that arrives after a long run of
|
|
6
|
+
prompts must be confirmed by typing its key word, not by the `y` that momentum types. Neither
|
|
7
|
+
rule ever answers a prompt on the person's behalf; both only make an approval harder.
|
|
8
|
+
"""
|
|
9
|
+
import collections
|
|
10
|
+
import time
|
|
11
|
+
|
|
12
|
+
from server.shared.irreversible import IRREVERSIBLE, irreversible # noqa: F401 the client reads both from here
|
|
13
|
+
|
|
14
|
+
FAST = 1.0 # seconds: an approval quicker than this was not read
|
|
15
|
+
RUN = 3 # quick approvals in a row before the client slows down
|
|
16
|
+
MIN_READ = 2.0 # seconds a slowed prompt must be on screen before an approval counts
|
|
17
|
+
LONG_RUN = 5 # prompts answered within WINDOW that make a run "long"
|
|
18
|
+
WINDOW = 600.0
|
|
19
|
+
|
|
20
|
+
|
|
21
|
+
class Attention:
|
|
22
|
+
"""This terminal session's permission answers: when, how fast, and whether allowed."""
|
|
23
|
+
|
|
24
|
+
def __init__(self, clock=time.monotonic):
|
|
25
|
+
self.clock = clock
|
|
26
|
+
self.answers = collections.deque(maxlen=200)
|
|
27
|
+
|
|
28
|
+
def record(self, seconds, allowed):
|
|
29
|
+
self.answers.append((self.clock(), float(seconds), bool(allowed)))
|
|
30
|
+
|
|
31
|
+
def quick_run(self):
|
|
32
|
+
"""Trailing approvals, each given in under FAST seconds."""
|
|
33
|
+
count = 0
|
|
34
|
+
for _, seconds, allowed in reversed(self.answers):
|
|
35
|
+
if not allowed or seconds >= FAST:
|
|
36
|
+
break
|
|
37
|
+
count += 1
|
|
38
|
+
return count
|
|
39
|
+
|
|
40
|
+
def recent(self):
|
|
41
|
+
now = self.clock()
|
|
42
|
+
return sum(1 for at, _, _ in self.answers if now - at <= WINDOW)
|
|
43
|
+
|
|
44
|
+
def rules(self, tool, data):
|
|
45
|
+
"""What the next prompt must do: {'slow': note or None, 'confirm': (word, note) or None}."""
|
|
46
|
+
slow = None
|
|
47
|
+
if self.quick_run() >= RUN:
|
|
48
|
+
slow = ('The last %d approvals each took under a second. Read this one: an approval in the first %d '
|
|
49
|
+
'seconds is not taken. For commands you always allow, a policy (/permissions) is better than '
|
|
50
|
+
'prompts.' % (self.quick_run(), int(MIN_READ)))
|
|
51
|
+
confirm = None
|
|
52
|
+
found = irreversible(tool, data)
|
|
53
|
+
if found and (self.recent() >= LONG_RUN or slow):
|
|
54
|
+
word, reason = found
|
|
55
|
+
confirm = (word, 'This %s and cannot be undone here, and it comes after %d prompts in the last %d minutes. '
|
|
56
|
+
'Type "%s" to allow it; y is not enough.' % (reason, self.recent(), int(WINDOW // 60), word))
|
|
57
|
+
return {'slow': slow, 'confirm': confirm}
|